// THIS FILE HAS BEEN AUTO-GENERATED BY THE 'DEAR BINDINGS' GENERATOR.
// **DO NOT EDIT DIRECTLY**
// https://github.com/dearimgui/dear_bindings
// MIT License
// Auto-generated forward declarations for C header
typedef struct ImPlotSpec_t ImPlotSpec;
typedef struct ImPlotPoint_t ImPlotPoint;
typedef struct ImPlotRange_t ImPlotRange;
typedef struct ImPlotRect_t ImPlotRect;
typedef struct ImPlotStyle_t ImPlotStyle;
typedef struct ImPlotInputMap_t ImPlotInputMap;
// ImDrawIdx: vertex index. [Compile-time configurable type]
// - To use 16-bit indices + allow large meshes: backend need to set 'io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset' and handle ImDrawCmd::VtxOffset (recommended).
// - To use 32-bit indices: override with '#define ImDrawIdx unsigned int' in your imconfig.h file.
#ifndef ImDrawIdx
typedef unsigned short ImDrawIdx; // Default: 16-bit (for maximum compatibility with renderer backends)
#endif // #ifndef ImDrawIdx
// Copyright (c) 2020-2024 Evan Pezent
// Copyright (c) 2025-2026 Breno Cunha Queiroz
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// ImPlot v1.1 WIP
// Table of Contents:
//
// [SECTION] Macros and Defines
// [SECTION] Enums and Types
// [SECTION] Callbacks
// [SECTION] Contexts
// [SECTION] Begin/End Plot
// [SECTION] Begin/End Subplot
// [SECTION] Setup
// [SECTION] SetNext
// [SECTION] Plot Items
// [SECTION] Plot Tools
// [SECTION] Plot Utils
// [SECTION] Legend Utils
// [SECTION] Drag and Drop
// [SECTION] Styling
// [SECTION] Colormaps
// [SECTION] Input Mapping
// [SECTION] Miscellaneous
// [SECTION] Demo
// [SECTION] Obsolete API
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include "dcimgui.h"
#ifndef IMGUI_DISABLE
// [SECTION] Macros and Defines
//-----------------------------------------------------------------------------
// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
// Using ImPlot via a shared library is not recommended, because we don't guarantee
// backward nor forward ABI compatibility and also function call overhead. If you
// do use ImPlot as a DLL, be sure to call SetImGuiContext (see Miscellaneous section).
#ifndef CIMGUI_API
#define CIMGUI_API
#endif // #ifndef CIMGUI_API
// ImPlot version string.
#define IMPLOT_VERSION "1.1 WIP"
// ImPlot version integer encoded as XYYZZ (X=major, YY=minor, ZZ=patch).
#define IMPLOT_VERSION_NUM 10100
// Macro for templated plotting functions; keeps header clean.
#define IMPLOT_TMP template <typename T> CIMGUI_API
// Indicates variable should deduced automatically.
// Special color used to indicate that a color should be deduced automatically.
//-----------------------------------------------------------------------------
// [SECTION] Enums and Types
//-----------------------------------------------------------------------------
// Forward declarations
typedef struct ImPlotContext_t ImPlotContext; // ImPlot context (opaque struct, see implot_internal.h)
// Enums/Flags
typedef int ImAxis; // -> enum ImAxis_
typedef int ImPlotProp; // -> enum ImPlotProp_
typedef int ImPlotFlags; // -> enum ImPlotFlags_
typedef int ImPlotAxisFlags; // -> enum ImPlotAxisFlags_
typedef int ImPlotSubplotFlags; // -> enum ImPlotSubplotFlags_
typedef int ImPlotLegendFlags; // -> enum ImPlotLegendFlags_
typedef int ImPlotMouseTextFlags; // -> enum ImPlotMouseTextFlags_
typedef int ImPlotDragToolFlags; // -> ImPlotDragToolFlags_
typedef int ImPlotColormapScaleFlags; // -> ImPlotColormapScaleFlags_
typedef int ImPlotItemFlags; // -> ImPlotItemFlags_
typedef int ImPlotLineFlags; // -> ImPlotLineFlags_
typedef int ImPlotScatterFlags; // -> ImPlotScatterFlags
typedef int ImPlotBubblesFlags; // -> ImPlotBubblesFlags
typedef int ImPlotPolygonFlags; // -> ImPlotPolygonFlags_
typedef int ImPlotStairsFlags; // -> ImPlotStairsFlags_
typedef int ImPlotShadedFlags; // -> ImPlotShadedFlags_
typedef int ImPlotBarsFlags; // -> ImPlotBarsFlags_
typedef int ImPlotBarGroupsFlags; // -> ImPlotBarGroupsFlags_
typedef int ImPlotErrorBarsFlags; // -> ImPlotErrorBarsFlags_
typedef int ImPlotStemsFlags; // -> ImPlotStemsFlags_
typedef int ImPlotInfLinesFlags; // -> ImPlotInfLinesFlags_
typedef int ImPlotPieChartFlags; // -> ImPlotPieChartFlags_
typedef int ImPlotHeatmapFlags; // -> ImPlotHeatmapFlags_
typedef int ImPlotHistogramFlags; // -> ImPlotHistogramFlags_
typedef int ImPlotDigitalFlags; // -> ImPlotDigitalFlags_
typedef int ImPlotImageFlags; // -> ImPlotImageFlags_
typedef int ImPlotTextFlags; // -> ImPlotTextFlags_
typedef int ImPlotDummyFlags; // -> ImPlotDummyFlags_
typedef int ImPlotCond; // -> enum ImPlotCond_
typedef int ImPlotCol; // -> enum ImPlotCol_
typedef int ImPlotStyleVar; // -> enum ImPlotStyleVar_
typedef int ImPlotScale; // -> enum ImPlotScale_
typedef int ImPlotMarker; // -> enum ImPlotMarker_
typedef int ImPlotColormap; // -> enum ImPlotColormap_
typedef int ImPlotLocation; // -> enum ImPlotLocation_
typedef int ImPlotBin; // -> enum ImPlotBin_
// Axis indices. The values assigned may change; NEVER hardcode these.
typedef enum
{
// horizontal axes
ImAxis_X1 = 0, // enabled by default
ImAxis_X2, // disabled by default
ImAxis_X3, // disabled by default
// vertical axes
ImAxis_Y1, // enabled by default
ImAxis_Y2, // disabled by default
ImAxis_Y3, // disabled by default
// bookkeeping
ImAxis_COUNT,
} ImAxis_;
// Plotting properties. These provide syntactic sugar for creating ImPlotSpecs from (ImPlotProp,value) pairs. See ImPlotSpec documentation.
typedef enum
{
ImPlotProp_LineColor, // line color (applies to lines, bar edges); IMPLOT_AUTO_COL will use next Colormap color or current item color
ImPlotProp_LineColors, // array of colors for each line; if nullptr, use LineColor for all lines
ImPlotProp_LineWeight, // line weight in pixels (applies to lines, bar edges, marker edges)
ImPlotProp_FillColor, // fill color (applies to shaded regions, bar faces); IMPLOT_AUTO_COL will use next Colormap color or current item color
ImPlotProp_FillColors, // array of colors for each fill; if nullptr, use FillColor for all fills
ImPlotProp_FillAlpha, // alpha multiplier (applies to FillColor, FillColors, MarkerFillColor, and MarkerFillColors)
ImPlotProp_Marker, // marker type; specify ImPlotMarker_Auto to use the next unused marker
ImPlotProp_MarkerSize, // size of markers (radius) *in pixels*
ImPlotProp_MarkerSizes, // array of sizes for each marker; if nullptr, use MarkerSize for all markers
ImPlotProp_MarkerLineColor, // marker edge color; IMPLOT_AUTO_COL will use LineColor
ImPlotProp_MarkerLineColors, // array of colors for each marker edge; if nullptr, use MarkerLineColor for all markers
ImPlotProp_MarkerFillColor, // marker face color; IMPLOT_AUTO_COL will use LineColor
ImPlotProp_MarkerFillColors, // array of colors for each marker face; if nullptr, use MarkerFillColor for all markers
ImPlotProp_Size, // size of error bar whiskers (width or height), and digital bars (height) *in pixels*
ImPlotProp_Offset, // data index offset
ImPlotProp_Stride, // data stride in bytes; IMPLOT_AUTO will result in sizeof(T) where T is the type passed to PlotX
ImPlotProp_Flags, // optional item flags; can be composed from common ImPlotItemFlags and/or specialized ImPlotXFlags
} ImPlotProp_;
// Options for plots (see BeginPlot).
typedef enum
{
ImPlotFlags_None = 0, // default
ImPlotFlags_NoTitle = 1<<0, // the plot title will not be displayed (titles are also hidden if preceded by double hashes, e.g. "##MyPlot")
ImPlotFlags_NoLegend = 1<<1, // the legend will not be displayed
ImPlotFlags_NoMouseText = 1<<2, // the mouse position, in plot coordinates, will not be displayed inside of the plot
ImPlotFlags_NoInputs = 1<<3, // the user will not be able to interact with the plot
ImPlotFlags_NoMenus = 1<<4, // the user will not be able to open context menus
ImPlotFlags_NoBoxSelect = 1<<5, // the user will not be able to box-select
ImPlotFlags_NoFrame = 1<<6, // the ImGui frame will not be rendered
ImPlotFlags_Equal = 1<<7, // x and y axes pairs will be constrained to have the same units/pixel
ImPlotFlags_Crosshairs = 1<<8, // the default mouse cursor will be replaced with a crosshair when hovered
ImPlotFlags_CanvasOnly = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText,
} ImPlotFlags_;
// Options for plot axes (see SetupAxis).
typedef enum
{
ImPlotAxisFlags_None = 0, // default
ImPlotAxisFlags_NoLabel = 1<<0, // the axis label will not be displayed (axis labels are also hidden if the supplied string name is nullptr)
ImPlotAxisFlags_NoGridLines = 1<<1, // no grid lines will be displayed
ImPlotAxisFlags_NoTickMarks = 1<<2, // no tick marks will be displayed
ImPlotAxisFlags_NoTickLabels = 1<<3, // no text labels will be displayed
ImPlotAxisFlags_NoInitialFit = 1<<4, // axis will not be initially fit to data extents on the first rendered frame
ImPlotAxisFlags_NoMenus = 1<<5, // the user will not be able to open context menus with right-click
ImPlotAxisFlags_NoSideSwitch = 1<<6, // the user will not be able to switch the axis side by dragging it
ImPlotAxisFlags_NoHighlight = 1<<7, // the axis will not have its background highlighted when hovered or held
ImPlotAxisFlags_Opposite = 1<<8, // axis ticks and labels will be rendered on the conventionally opposite side (i.e, right or top)
ImPlotAxisFlags_Foreground = 1<<9, // grid lines will be displayed in the foreground (i.e. on top of data) instead of the background
ImPlotAxisFlags_Invert = 1<<10, // the axis will be inverted
ImPlotAxisFlags_AutoFit = 1<<11, // axis will be auto-fitting to data extents
ImPlotAxisFlags_RangeFit = 1<<12, // axis will only fit points if the point is in the visible range of the **orthogonal** axis
ImPlotAxisFlags_PanStretch = 1<<13, // panning in a locked or constrained state will cause the axis to stretch if possible
ImPlotAxisFlags_LockMin = 1<<14, // the axis minimum value will be locked when panning/zooming
ImPlotAxisFlags_LockMax = 1<<15, // the axis maximum value will be locked when panning/zooming
ImPlotAxisFlags_Lock = ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax,
ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels,
ImPlotAxisFlags_AuxDefault = ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite,
} ImPlotAxisFlags_;
// Options for subplots (see BeginSubplot)
typedef enum
{
ImPlotSubplotFlags_None = 0, // default
ImPlotSubplotFlags_NoTitle = 1<<0, // the subplot title will not be displayed (titles are also hidden if preceded by double hashes, e.g. "##MySubplot")
ImPlotSubplotFlags_NoLegend = 1<<1, // the legend will not be displayed (only applicable if ImPlotSubplotFlags_ShareItems is enabled)
ImPlotSubplotFlags_NoMenus = 1<<2, // the user will not be able to open context menus with right-click
ImPlotSubplotFlags_NoResize = 1<<3, // resize splitters between subplot cells will be not be provided
ImPlotSubplotFlags_NoAlign = 1<<4, // subplot edges will not be aligned vertically or horizontally
ImPlotSubplotFlags_ShareItems = 1<<5, // items across all subplots will be shared and rendered into a single legend entry
ImPlotSubplotFlags_LinkRows = 1<<6, // link the y-axis limits of all plots in each row (does not apply to auxiliary axes)
ImPlotSubplotFlags_LinkCols = 1<<7, // link the x-axis limits of all plots in each column (does not apply to auxiliary axes)
ImPlotSubplotFlags_LinkAllX = 1<<8, // link the x-axis limits in every plot in the subplot (does not apply to auxiliary axes)
ImPlotSubplotFlags_LinkAllY = 1<<9, // link the y-axis limits in every plot in the subplot (does not apply to auxiliary axes)
ImPlotSubplotFlags_ColMajor = 1<<10, // subplots are added in column major order instead of the default row major order
} ImPlotSubplotFlags_;
// Options for legends (see SetupLegend)
typedef enum
{
ImPlotLegendFlags_None = 0, // default
ImPlotLegendFlags_NoButtons = 1<<0, // legend icons will not function as hide/show buttons
ImPlotLegendFlags_NoHighlightItem = 1<<1, // plot items will not be highlighted when their legend entry is hovered
ImPlotLegendFlags_NoHighlightAxis = 1<<2, // axes will not be highlighted when legend entries are hovered (only relevant if x/y-axis count > 1)
ImPlotLegendFlags_NoMenus = 1<<3, // the user will not be able to open context menus with right-click
ImPlotLegendFlags_Outside = 1<<4, // legend will be rendered outside of the plot area
ImPlotLegendFlags_Horizontal = 1<<5, // legend entries will be displayed horizontally
ImPlotLegendFlags_Sort = 1<<6, // legend entries will be displayed in alphabetical order
ImPlotLegendFlags_Reverse = 1<<7, // legend entries will be displayed in reverse order
} ImPlotLegendFlags_;
// Options for mouse hover text (see SetupMouseText)
typedef enum
{
ImPlotMouseTextFlags_None = 0, // default
ImPlotMouseTextFlags_NoAuxAxes = 1<<0, // only show the mouse position for primary axes
ImPlotMouseTextFlags_NoFormat = 1<<1, // axes label formatters won't be used to render text
ImPlotMouseTextFlags_ShowAlways = 1<<2, // always display mouse position even if plot not hovered
} ImPlotMouseTextFlags_;
// Options for DragPoint, DragLine, DragRect
typedef enum
{
ImPlotDragToolFlags_None = 0, // default
ImPlotDragToolFlags_NoCursors = 1<<0, // drag tools won't change cursor icons when hovered or held
ImPlotDragToolFlags_NoFit = 1<<1, // the drag tool won't be considered for plot fits
ImPlotDragToolFlags_NoInputs = 1<<2, // lock the tool from user inputs
ImPlotDragToolFlags_Delayed = 1<<3, // tool rendering will be delayed one frame; useful when applying position-constraints
} ImPlotDragToolFlags_;
// Flags for ColormapScale
typedef enum
{
ImPlotColormapScaleFlags_None = 0, // default
ImPlotColormapScaleFlags_NoLabel = 1<<0, // the colormap axis label will not be displayed
ImPlotColormapScaleFlags_Opposite = 1<<1, // render the colormap label and tick labels on the opposite side
ImPlotColormapScaleFlags_Invert = 1<<2, // invert the colormap bar and axis scale (this only affects rendering; if you only want to reverse the scale mapping, make scale_min > scale_max)
} ImPlotColormapScaleFlags_;
// Flags for ANY PlotX function. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotItemFlags_None = 0,
ImPlotItemFlags_NoLegend = 1<<0, // the item won't have a legend entry displayed
ImPlotItemFlags_NoFit = 1<<1, // the item won't be considered for plot fits
} ImPlotItemFlags_;
// Flags for PlotLine. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotLineFlags_None = 0, // default
ImPlotLineFlags_Segments = 1<<10, // a line segment will be rendered from every two consecutive points
ImPlotLineFlags_Loop = 1<<11, // the last and first point will be connected to form a closed loop
ImPlotLineFlags_SkipNaN = 1<<12, // NaNs values will be skipped instead of rendered as missing data
ImPlotLineFlags_NoClip = 1<<13, // markers (if displayed) on the edge of a plot will not be clipped
ImPlotLineFlags_Shaded = 1<<14, // a filled region between the line and horizontal origin will be rendered; use PlotShaded for more advanced cases
} ImPlotLineFlags_;
// Flags for PlotScatter. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotScatterFlags_None = 0, // default
ImPlotScatterFlags_NoClip = 1<<10, // markers on the edge of a plot will not be clipped
} ImPlotScatterFlags_;
// Flags for PlotBubbles. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotBubblesFlags_None = 0, // default
} ImPlotBubblesFlags_;
// Flags for PlotPolygon. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotPolygonFlags_None = 0, // default (closed, convex polygon)
ImPlotPolygonFlags_Concave = 1<<10, // use concave polygon filling (slower but supports concave shapes)
} ImPlotPolygonFlags_;
// Flags for PlotStairs. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotStairsFlags_None = 0, // default
ImPlotStairsFlags_PreStep = 1<<10, // the y value is continued constantly to the left from every x position, i.e. the interval (x[i-1], x[i]] has the value y[i]
ImPlotStairsFlags_Shaded = 1<<11, // a filled region between the stairs and horizontal origin will be rendered; use PlotShaded for more advanced cases
} ImPlotStairsFlags_;
// Flags for PlotShaded (placeholder). Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotShadedFlags_None = 0, // default
} ImPlotShadedFlags_;
// Flags for PlotBars. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotBarsFlags_None = 0, // default
ImPlotBarsFlags_Horizontal = 1<<10, // bars will be rendered horizontally on the current y-axis
} ImPlotBarsFlags_;
// Flags for PlotBarGroups. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotBarGroupsFlags_None = 0, // default
ImPlotBarGroupsFlags_Horizontal = 1<<10, // bar groups will be rendered horizontally on the current y-axis
ImPlotBarGroupsFlags_Stacked = 1<<11, // items in a group will be stacked on top of each other
} ImPlotBarGroupsFlags_;
// Flags for PlotErrorBars. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotErrorBarsFlags_None = 0, // default
ImPlotErrorBarsFlags_Horizontal = 1<<10, // error bars will be rendered horizontally on the current y-axis
} ImPlotErrorBarsFlags_;
// Flags for PlotStems. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotStemsFlags_None = 0, // default
ImPlotStemsFlags_Horizontal = 1<<10, // stems will be rendered horizontally on the current y-axis
} ImPlotStemsFlags_;
// Flags for PlotInfLines. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotInfLinesFlags_None = 0, // default
ImPlotInfLinesFlags_Horizontal = 1<<10, // lines will be rendered horizontally on the current y-axis
} ImPlotInfLinesFlags_;
// Flags for PlotPieChart. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotPieChartFlags_None = 0, // default
ImPlotPieChartFlags_Normalize = 1<<10, // force normalization of pie chart values (i.e. always make a full circle if sum < 0)
ImPlotPieChartFlags_IgnoreHidden = 1<<11, // ignore hidden slices when drawing the pie chart (as if they were not there)
ImPlotPieChartFlags_Exploding = 1<<12, // explode legend-hovered slice
ImPlotPieChartFlags_NoSliceBorder = 1<<13, // do not draw slice borders
} ImPlotPieChartFlags_;
// Flags for PlotHeatmap. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotHeatmapFlags_None = 0, // default
ImPlotHeatmapFlags_ColMajor = 1<<10, // data will be read in column major order
} ImPlotHeatmapFlags_;
// Flags for PlotHistogram and PlotHistogram2D. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotHistogramFlags_None = 0, // default
ImPlotHistogramFlags_Horizontal = 1<<10, // histogram bars will be rendered horizontally (not supported by PlotHistogram2D)
ImPlotHistogramFlags_Cumulative = 1<<11, // each bin will contain its count plus the counts of all previous bins (not supported by PlotHistogram2D)
ImPlotHistogramFlags_Density = 1<<12, // counts will be normalized, i.e. the PDF will be visualized, or the CDF will be visualized if Cumulative is also set
ImPlotHistogramFlags_NoOutliers = 1<<13, // exclude values outside the specified histogram range from the count toward normalizing and cumulative counts
ImPlotHistogramFlags_ColMajor = 1<<14, // data will be read in column major order (not supported by PlotHistogram)
} ImPlotHistogramFlags_;
// Flags for PlotDigital (placeholder). Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotDigitalFlags_None = 0, // default
} ImPlotDigitalFlags_;
// Flags for PlotImage (placeholder). Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotImageFlags_None = 0, // default
} ImPlotImageFlags_;
// Flags for PlotText. Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotTextFlags_None = 0, // default
ImPlotTextFlags_Vertical = 1<<10, // text will be rendered vertically
} ImPlotTextFlags_;
// Flags for PlotDummy (placeholder). Used by setting ImPlotSpec::Flags.
typedef enum
{
ImPlotDummyFlags_None = 0, // default
} ImPlotDummyFlags_;
// Represents a condition for SetupAxisLimits etc. (same as ImGuiCond, but we only support a subset of those enums)
typedef enum
{
ImPlotCond_None = ImGuiCond_None, // No condition (always set the variable), same as _Always
ImPlotCond_Always = ImGuiCond_Always, // No condition (always set the variable)
ImPlotCond_Once = ImGuiCond_Once, // Set the variable once per runtime session (only the first call will succeed)
} ImPlotCond_;
// Plot styling colors.
typedef enum
{
ImPlotCol_FrameBg, // plot frame background color (defaults to ImGuiCol_FrameBg)
ImPlotCol_PlotBg, // plot area background color (defaults to ImGuiCol_WindowBg)
ImPlotCol_PlotBorder, // plot area border color (defaults to ImGuiCol_Border)
ImPlotCol_LegendBg, // legend background color (defaults to ImGuiCol_PopupBg)
ImPlotCol_LegendBorder, // legend border color (defaults to ImPlotCol_PlotBorder)
ImPlotCol_LegendText, // legend text color (defaults to ImPlotCol_InlayText)
ImPlotCol_TitleText, // plot title text color (defaults to ImGuiCol_Text)
ImPlotCol_InlayText, // color of text appearing inside of plots (defaults to ImGuiCol_Text)
ImPlotCol_AxisText, // axis label and tick labels color (defaults to ImGuiCol_Text)
ImPlotCol_AxisGrid, // axis grid color (defaults to 25% ImPlotCol_AxisText)
ImPlotCol_AxisTick, // axis tick color (defaults to AxisGrid)
ImPlotCol_AxisBg, // background color of axis hover region (defaults to transparent)
ImPlotCol_AxisBgHovered, // axis hover color (defaults to ImGuiCol_ButtonHovered)
ImPlotCol_AxisBgActive, // axis active color (defaults to ImGuiCol_ButtonActive)
ImPlotCol_Selection, // box-selection color (defaults to yellow)
ImPlotCol_Crosshairs, // crosshairs color (defaults to ImPlotCol_PlotBorder)
ImPlotCol_COUNT,
} ImPlotCol_;
// Plot styling variables.
typedef enum
{
ImPlotStyleVar_PlotDefaultSize, // ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot
ImPlotStyleVar_PlotMinSize, // ImVec2, minimum size plot frame can be when shrunk
ImPlotStyleVar_PlotBorderSize, // float, thickness of border around plot area
ImPlotStyleVar_MinorAlpha, // float, alpha multiplier applied to minor axis grid lines
ImPlotStyleVar_MajorTickLen, // ImVec2, major tick lengths for X and Y axes
ImPlotStyleVar_MinorTickLen, // ImVec2, minor tick lengths for X and Y axes
ImPlotStyleVar_MajorTickSize, // ImVec2, line thickness of major ticks
ImPlotStyleVar_MinorTickSize, // ImVec2, line thickness of minor ticks
ImPlotStyleVar_MajorGridSize, // ImVec2, line thickness of major grid lines
ImPlotStyleVar_MinorGridSize, // ImVec2, line thickness of minor grid lines
ImPlotStyleVar_PlotPadding, // ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
ImPlotStyleVar_LabelPadding, // ImVec2, padding between axes labels, tick labels, and plot edge
ImPlotStyleVar_LegendPadding, // ImVec2, legend padding from plot edges
ImPlotStyleVar_LegendInnerPadding, // ImVec2, legend inner padding from legend edges
ImPlotStyleVar_LegendSpacing, // ImVec2, spacing between legend entries
ImPlotStyleVar_MousePosPadding, // ImVec2, padding between plot edge and interior info text
ImPlotStyleVar_AnnotationPadding, // ImVec2, text padding around annotation labels
ImPlotStyleVar_FitPadding, // ImVec2, additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
ImPlotStyleVar_DigitalPadding, // float, digital plot padding from bottom in pixels
ImPlotStyleVar_DigitalSpacing, // float, digital plot spacing gap in pixels
ImPlotStyleVar_COUNT,
} ImPlotStyleVar_;
// Axis scale
typedef enum
{
ImPlotScale_Linear = 0, // default linear scale
ImPlotScale_Time, // date/time scale
ImPlotScale_Log10, // base 10 logarithmic scale
ImPlotScale_SymLog, // symmetric log scale
} ImPlotScale_;
// Marker specifications.
typedef enum
{
ImPlotMarker_None = -2, // no marker
ImPlotMarker_Auto = -1, // automatic marker selection
ImPlotMarker_Circle, // a circle marker (default)
ImPlotMarker_Square, // a square maker
ImPlotMarker_Diamond, // a diamond marker
ImPlotMarker_Up, // an upward-pointing triangle marker
ImPlotMarker_Down, // an downward-pointing triangle marker
ImPlotMarker_Left, // an leftward-pointing triangle marker
ImPlotMarker_Right, // an rightward-pointing triangle marker
ImPlotMarker_Cross, // a cross marker (not fill-able)
ImPlotMarker_Plus, // a plus marker (not fill-able)
ImPlotMarker_Asterisk, // a asterisk marker (not fill-able)
ImPlotMarker_Vertical, // a vertical line marker (not fill-able)
ImPlotMarker_Horizontal, // a horizontal line marker (not fill-able)
ImPlotMarker_COUNT,
} ImPlotMarker_;
// Built-in colormaps
typedef enum
{
ImPlotColormap_Deep = 0, // a.k.a. seaborn deep (qual=true, n=10) (default)
ImPlotColormap_Dark = 1, // a.k.a. matplotlib "Set1" (qual=true, n=9 )
ImPlotColormap_Pastel = 2, // a.k.a. matplotlib "Pastel1" (qual=true, n=9 )
ImPlotColormap_Paired = 3, // a.k.a. matplotlib "Paired" (qual=true, n=12)
ImPlotColormap_Viridis = 4, // a.k.a. matplotlib "viridis" (qual=false, n=11)
ImPlotColormap_Plasma = 5, // a.k.a. matplotlib "plasma" (qual=false, n=11)
ImPlotColormap_Hot = 6, // a.k.a. matplotlib/MATLAB "hot" (qual=false, n=11)
ImPlotColormap_Cool = 7, // a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11)
ImPlotColormap_Pink = 8, // a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11)
ImPlotColormap_Jet = 9, // a.k.a. MATLAB "jet" (qual=false, n=11)
ImPlotColormap_Twilight = 10, // a.k.a. matplotlib "twilight" (qual=false, n=11)
ImPlotColormap_RdBu = 11, // red/blue, Color Brewer (qual=false, n=11)
ImPlotColormap_BrBG = 12, // brown/blue-green, Color Brewer (qual=false, n=11)
ImPlotColormap_PiYG = 13, // pink/yellow-green, Color Brewer (qual=false, n=11)
ImPlotColormap_Spectral = 14, // color spectrum, Color Brewer (qual=false, n=11)
ImPlotColormap_Greys = 15, // white/black (qual=false, n=2 )
} ImPlotColormap_;
// Used to position items on a plot (e.g. legends, labels, etc.)
typedef enum
{
ImPlotLocation_Center = 0, // center-center
ImPlotLocation_North = 1<<0, // top-center
ImPlotLocation_South = 1<<1, // bottom-center
ImPlotLocation_West = 1<<2, // center-left
ImPlotLocation_East = 1<<3, // center-right
ImPlotLocation_NorthWest = ImPlotLocation_North | ImPlotLocation_West, // top-left
ImPlotLocation_NorthEast = ImPlotLocation_North | ImPlotLocation_East, // top-right
ImPlotLocation_SouthWest = ImPlotLocation_South | ImPlotLocation_West, // bottom-left
ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East, // bottom-right
} ImPlotLocation_;
// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
typedef enum
{
ImPlotBin_Sqrt = -1, // k = sqrt(n)
ImPlotBin_Sturges = -2, // k = 1 + log2(n)
ImPlotBin_Rice = -3, // k = 2 * cbrt(n)
ImPlotBin_Scott = -4, // w = 3.49 * sigma / cbrt(n)
} ImPlotBin_;
// 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:
//
// ImPlotSpec spec;
// spec.LineColor = ImVec4(1,0,0,1);
// spec.LineWeight = 2.0f;
// spec.Marker = ImPlotMarker_Circle;
// spec.Flags = ImPlotItemFlags_NoLegend | ImPlotLineFlags_Segments;
// ImPlot::PlotLine("MyLine", xs, ys, 100, spec);
//
// 2. Inline using (ImPlotProp,value) pairs (order does NOT matter):
//
// ImPlot::PlotLine("MyLine", xs, ys, 100, {
// ImPlotProp_LineColor, ImVec4(1,0,0,1),
// ImPlotProp_LineWeight, 2.0f,
// ImPlotProp_Marker, ImPlotMarker_Circle,
// ImPlotProp_Flags, ImPlotItemFlags_NoLegend | ImPlotLineFlags_Segments
// });
struct ImPlotSpec_t
{
ImVec4 LineColor /* = IMPLOT_AUTO_COL */; // line color (applies to lines, bar edges); IMPLOT_AUTO_COL will use next Colormap color or current item color
ImU32* LineColors /* = nullptr */; // array of colors for each line; if nullptr, use LineColor for all lines
float LineWeight /* = 1.0f */; // line weight in pixels (applies to lines, bar edges, marker edges)
ImVec4 FillColor /* = IMPLOT_AUTO_COL */; // fill color (applies to shaded regions, bar faces); IMPLOT_AUTO_COL will use next Colormap color or current item color
ImU32* FillColors /* = nullptr */; // array of colors for each fill; if nullptr, use FillColor for all fills
float FillAlpha /* = 1.0f */; // alpha multiplier (applies to FillColor, FillColors, MarkerFillColor, and MarkerFillColors)
ImPlotMarker Marker /* = ImPlotMarker_None */; // marker type; specify ImPlotMarker_Auto to use the next unused marker
float MarkerSize /* = 4 */; // size of markers (radius) *in pixels*
float* MarkerSizes /* = nullptr */; // array of sizes for each marker; if nullptr, use MarkerSize for all markers
ImVec4 MarkerLineColor /* = IMPLOT_AUTO_COL */; // marker edge color; IMPLOT_AUTO_COL will use LineColor
ImU32* MarkerLineColors /* = nullptr */; // array of colors for each marker edge; if nullptr, use MarkerLineColor for all markers
ImVec4 MarkerFillColor /* = IMPLOT_AUTO_COL */; // marker face color; IMPLOT_AUTO_COL will use LineColor
ImU32* MarkerFillColors /* = nullptr */; // array of colors for each marker face; if nullptr, use MarkerFillColor for all markers
float Size /* = 4 */; // size of error bar whiskers (width or height), and digital bars (height) *in pixels*
int Offset /* = 0 */; // data index offset
int Stride /* = IMPLOT_AUTO */; // data stride in bytes; IMPLOT_AUTO will result in sizeof(T) where T is the type passed to PlotX
ImPlotItemFlags Flags /* = ImPlotItemFlags_None */; // optional item flags; can be composed from common ImPlotItemFlags and/or specialized ImPlotXFlags
};
// Double precision version of ImVec2 used by ImPlot. Extensible by end users.
IM_MSVC_RUNTIME_CHECKS_OFF
struct ImPlotPoint_t
{
double x, y;
#ifdef IMPLOT_POINT_CLASS_EXTRA
IMPLOT_POINT_CLASS_EXTRA // Define additional constructors and implicit cast operators in imconfig.h
// to convert back and forth between your math types and ImPlotPoint.
#endif // #ifdef IMPLOT_POINT_CLASS_EXTRA
};
IM_MSVC_RUNTIME_CHECKS_RESTORE
// Range defined by a min/max value.
struct ImPlotRange_t
{
double Min, Max;
};
CIMGUI_API bool ImPlotRange_Contains(const ImPlotRange* self, double value);
CIMGUI_API double ImPlotRange_Size(const ImPlotRange* self);
CIMGUI_API double ImPlotRange_Clamp(const ImPlotRange* self, double value);
// Combination of two range limits for X and Y axes. Also an AABB defined by Min()/Max().
struct ImPlotRect_t
{
ImPlotRange X, Y;
};
CIMGUI_API bool ImPlotRect_Contains(const ImPlotRect* self, ImPlotPoint p);
CIMGUI_API bool ImPlotRect_ContainsDouble(const ImPlotRect* self, double x, double y);
// Plot style structure
struct ImPlotStyle_t
{
// plot styling
ImVec2 PlotDefaultSize; // = 400,300 default size used when ImVec2(0,0) is passed to BeginPlot
ImVec2 PlotMinSize; // = 200,150 minimum size plot frame can be when shrunk
float PlotBorderSize; // = 1, line thickness of border around plot area
float MinorAlpha; // = 0.25 alpha multiplier applied to minor axis grid lines
ImVec2 MajorTickLen; // = 10,10 major tick lengths for X and Y axes
ImVec2 MinorTickLen; // = 5,5 minor tick lengths for X and Y axes
ImVec2 MajorTickSize; // = 1,1 line thickness of major ticks
ImVec2 MinorTickSize; // = 1,1 line thickness of minor ticks
ImVec2 MajorGridSize; // = 1,1 line thickness of major grid lines
ImVec2 MinorGridSize; // = 1,1 line thickness of minor grid lines
// plot padding
ImVec2 PlotPadding; // = 10,10 padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
ImVec2 LabelPadding; // = 5,5 padding between axes labels, tick labels, and plot edge
ImVec2 LegendPadding; // = 10,10 legend padding from plot edges
ImVec2 LegendInnerPadding; // = 5,5 legend inner padding from legend edges
ImVec2 LegendSpacing; // = 5,0 spacing between legend entries
ImVec2 MousePosPadding; // = 10,10 padding between plot edge and interior mouse location text
ImVec2 AnnotationPadding; // = 2,2 text padding around annotation labels
ImVec2 FitPadding; // = 0,0 additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
float DigitalPadding; // = 20, digital plot padding from bottom in pixels
float DigitalSpacing; // = 4, digital plot spacing gap in pixels
// style colors
ImVec4 Colors[ImPlotCol_COUNT]; // Array of styling colors. Indexable with ImPlotCol_ enums.
// colormap
ImPlotColormap Colormap; // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
// settings/flags
bool UseLocalTime; // = false, axis labels will be formatted for your timezone when ImPlotAxisFlag_Time is enabled
bool UseISO8601; // = false, dates will be formatted according to ISO 8601 where applicable (e.g. YYYY-MM-DD, YYYY-MM, --MM-DD, etc.)
bool Use24HourClock; // = false, times will be formatted using a 24 hour clock
};
// Support for legacy versions
// Input mapping structure. Default values listed. See also MapInputDefault, MapInputReverse.
struct ImPlotInputMap_t
{
ImGuiMouseButton Pan; // LMB enables panning when held,
int PanMod; // none optional modifier that must be held for panning/fitting
ImGuiMouseButton Fit; // LMB initiates fit when double clicked
ImGuiMouseButton Select; // RMB begins box selection when pressed and confirms selection when released
ImGuiMouseButton SelectCancel; // LMB cancels active box selection when pressed; cannot be same as Select
int SelectMod; // none optional modifier that must be held for box selection
int SelectHorzMod; // Alt expands active box selection horizontally to plot edge when held
int SelectVertMod; // Shift expands active box selection vertically to plot edge when held
ImGuiMouseButton Menu; // RMB opens context menus (if enabled) when clicked
int OverrideMod; // Ctrl when held, all input is ignored; used to enable axis/plots as DND sources
int ZoomMod; // none optional modifier that must be held for scroll wheel zooming
float ZoomRate; // 0.1f zoom rate for scroll (e.g. 0.1f = 10% plot range every scroll click); make negative to invert
};
//-----------------------------------------------------------------------------
// [SECTION] Callbacks
//-----------------------------------------------------------------------------
// Callback signature for axis tick label formatter.
typedef int (*ImPlotFormatter)(double value, char* buff, int size, void* user_data);
// Callback signature for data getter.
typedef ImPlotPoint (*ImPlotGetter)(int idx, void* user_data);
// Callback signature for axis transform.
typedef double (*ImPlotTransform)(double value, void* user_data);
//-----------------------------------------------------------------------------
// [SECTION] Contexts
//-----------------------------------------------------------------------------
// Creates a new ImPlot context. Call this after ImGui::CreateContext.
CIMGUI_API ImPlotContext* ImPlotCreateContext(void);
// Destroys an ImPlot context. Call this before ImGui::DestroyContext. nullptr = destroy current context.
CIMGUI_API void ImPlotDestroyContext(ImPlotContext* ctx /* = nullptr */);
// Returns the current ImPlot context. nullptr if no context has ben set.
CIMGUI_API ImPlotContext* ImPlotGetCurrentContext(void);
// Sets the current ImPlot context.
CIMGUI_API void ImPlotSetCurrentContext(ImPlotContext* ctx);
// Sets the current **ImGui** context. This is ONLY necessary if you are compiling
// ImPlot as a DLL (not recommended) separate from your ImGui compilation. It
// sets the global variable GImGui, which is not shared across DLL boundaries.
// See GImGui documentation in imgui.cpp for more details.
CIMGUI_API void ImPlotSetImGuiContext(ImGuiContext* ctx);
//-----------------------------------------------------------------------------
// [SECTION] Begin/End Plot
//-----------------------------------------------------------------------------
// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
// be called! You are encouraged to use the following convention:
//
// if (BeginPlot(...)) {
// PlotLine(...);
// ...
// 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. The default
// size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle.
CIMGUI_API bool ImPlotBeginPlot(const char* title_id, ImVec2 size /* = ImVec2(-1, 0) */, ImPlotFlags flags /* = 0 */);
// Only call EndPlot() if BeginPlot() returns true! Typically called at the end
// of an if statement conditioned on BeginPlot(). See example above.
CIMGUI_API void ImPlotEndPlot(void);
//-----------------------------------------------------------------------------
// [SECTION] Begin/End Subplots
//-----------------------------------------------------------------------------
// Starts a subdivided plotting context. If the function returns true,
// EndSubplots() MUST be called! Call BeginPlot/EndPlot AT MOST [rows*cols]
// times in between the beginning and end of the subplot context. Plots are
// added in row major order.
//
// Example:
//
// if (BeginSubplots("My Subplot",2,3,ImVec2(800,400)) {
// for (int i = 0; i < 6; ++i) {
// if (BeginPlot(...)) {
// ImPlot::PlotLine(...);
// ...
// EndPlot();
// }
// }
// EndSubplots();
// }
//
// Produces:
//
// [0] | [1] | [2]
// ----|-----|----
// [3] | [4] | [5]
//
// 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. "MySubplot##HiddenIdText" or "##NoTitle").
// - #rows and #cols must be greater than 0.
// - #size is the size of the entire grid of subplots, not the individual plots
// - #row_ratios and #col_ratios must have AT LEAST #rows and #cols elements,
// respectively. These are the sizes of the rows and columns expressed in ratios.
// If the user adjusts the dimensions, the arrays are updated with new ratios.
//
// Important notes regarding BeginPlot from inside of BeginSubplots:
//
// - The #title_id parameter of _BeginPlot_ (see above) does NOT have to be
// unique when called inside of a subplot context. Subplot IDs are hashed
// for your convenience so you don't have call PushID or generate unique title
// strings. Simply pass an empty string to BeginPlot unless you want to title
// each subplot.
// - The #size parameter of _BeginPlot_ (see above) is ignored when inside of a
// subplot context. The actual size of the subplot will be based on the
// #size value you pass to _BeginSubplots_ and #row/#col_ratios if provided.
CIMGUI_API bool ImPlotBeginSubplots(const char* title_id, int rows, int cols, ImVec2 size, ImPlotSubplotFlags flags /* = 0 */, float* row_ratios /* = nullptr */, float* col_ratios /* = nullptr */);
// Only call EndSubplots() if BeginSubplots() returns true! Typically called at the end
// of an if statement conditioned on BeginSubplots(). See example above.
CIMGUI_API void ImPlotEndSubplots(void);
//-----------------------------------------------------------------------------
// [SECTION] Setup
//-----------------------------------------------------------------------------
// 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 (BeginPlot(...)) { 1) begin a new plot
// SetupAxis(ImAxis_X1, "My X-Axis"); 2) make Setup calls
// SetupAxis(ImAxis_Y1, "My Y-Axis");
// SetupLegend(ImPlotLocation_North);
// ...
// SetupFinish(); 3) [optional] explicitly finish setup
// PlotLine(...); 4) plot items
// ...
// 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.
// Enables an axis or sets the label and/or flags for an existing axis. Leave #label = nullptr for no label.
CIMGUI_API void ImPlotSetupAxis(ImAxis axis, const char* label /* = nullptr */, ImPlotAxisFlags flags /* = 0 */);
// Sets an axis range limits. If ImPlotCond_Always is used, the axes limits will be locked. Inversion with v_min > v_max is not supported; use SetupAxisLimits instead.
CIMGUI_API void ImPlotSetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond /* = ImPlotCond_Once */);
// Links an axis range limits to external values. Set to nullptr for no linkage. The pointer data must remain valid until EndPlot.
CIMGUI_API void ImPlotSetupAxisLinks(ImAxis axis, double* link_min, double* link_max);
// Sets the format of numeric axis labels via formatter specifier (default="%g"). Formatted values will be double (i.e. use %f).
CIMGUI_API void ImPlotSetupAxisFormat(ImAxis axis, const char* fmt);
// Sets the format of numeric axis labels via formatter callback. Given #value, write a label into #buff. Optionally pass user data.
CIMGUI_API void ImPlotSetupAxisFormatImPlotFormatter(ImAxis axis, ImPlotFormatter formatter, void* data /* = nullptr */);
// Sets an axis' ticks and optionally the labels. To keep the default ticks, set #keep_default=true.
CIMGUI_API void ImPlotSetupAxisTicks(ImAxis axis, const double* values, int n_ticks, const char*const labels[] /* = nullptr */, bool keep_default /* = false */);
// Sets an axis' ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
CIMGUI_API void ImPlotSetupAxisTicksDouble(ImAxis axis, double v_min, double v_max, int n_ticks, const char*const labels[] /* = nullptr */, bool keep_default /* = false */);
// Sets an axis' scale using built-in options.
CIMGUI_API void ImPlotSetupAxisScale(ImAxis axis, ImPlotScale scale);
// Sets an axis' scale using user supplied forward and inverse transforms.
CIMGUI_API void ImPlotSetupAxisScaleImPlotTransform(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse, void* data /* = nullptr */);
// Sets an axis' limits constraints.
CIMGUI_API void ImPlotSetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max);
// Sets an axis' zoom constraints.
CIMGUI_API void ImPlotSetupAxisZoomConstraints(ImAxis axis, double z_min, double z_max);
// Sets the label and/or flags for primary X and Y axes (shorthand for two calls to SetupAxis).
CIMGUI_API void ImPlotSetupAxes(const char* x_label, const char* y_label, ImPlotAxisFlags x_flags /* = 0 */, ImPlotAxisFlags y_flags /* = 0 */);
// Sets the primary X and Y axes range limits. If ImPlotCond_Always is used, the axes limits will be locked (shorthand for two calls to SetupAxisLimits).
CIMGUI_API void ImPlotSetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond /* = ImPlotCond_Once */);
// Sets up the plot legend. This can also be called immediately after BeginSubplots when using ImPlotSubplotFlags_ShareItems.
CIMGUI_API void ImPlotSetupLegend(ImPlotLocation location, ImPlotLegendFlags flags /* = 0 */);
// Set the location of the current plot's mouse position text (default = South|East).
CIMGUI_API void ImPlotSetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags /* = 0 */);
// Explicitly finalize plot setup. Once you call this, you cannot make anymore Setup calls for the current plot!
// Note that calling this function is OPTIONAL; it will be called by the first subsequent setup-locking API call.
CIMGUI_API void ImPlotSetupFinish(void);
//-----------------------------------------------------------------------------
// [SECTION] SetNext
//-----------------------------------------------------------------------------
// Though you should default to the `Setup` API above, there are some scenarios
// where (re)configuring a plot or axis before `BeginPlot` is needed (e.g. if
// using a preceding button or slider widget to change the plot limits). In
// this case, you can use the `SetNext` API below. While this is not as feature
// rich as the Setup API, most common needs are provided. These functions can be
// called anywhere except for inside of `Begin/EndPlot`. For example:
// if (ImGui::Button("Center Plot"))
// ImPlot::SetNextPlotLimits(-1,1,-1,1);
// if (ImPlot::BeginPlot(...)) {
// ...
// ImPlot::EndPlot();
// }
//
// Important notes:
//
// - You must still enable non-default axes with SetupAxis for these functions
// to work properly.
// Sets an upcoming axis range limits. If ImPlotCond_Always is used, the axes limits will be locked.
CIMGUI_API void ImPlotSetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond /* = ImPlotCond_Once */);
// Links an upcoming axis range limits to external values. Set to nullptr for no linkage. The pointer data must remain valid until EndPlot!
CIMGUI_API void ImPlotSetNextAxisLinks(ImAxis axis, double* link_min, double* link_max);
// Set an upcoming axis to auto fit to its data.
CIMGUI_API void ImPlotSetNextAxisToFit(ImAxis axis);
// Sets the upcoming primary X and Y axes range limits. If ImPlotCond_Always is used, the axes limits will be locked (shorthand for two calls to SetupAxisLimits).
CIMGUI_API void ImPlotSetNextAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond /* = ImPlotCond_Once */);
// Sets all upcoming axes to auto fit to their data.
CIMGUI_API void ImPlotSetNextAxesToFit(void);
//-----------------------------------------------------------------------------
// [SECTION] Plot Items
//-----------------------------------------------------------------------------
// The main plotting API is provided below. Call these functions between
// Begin/EndPlot and after any Setup API calls. Each plots data on the current
// x and y axes, which can be changed with `SetAxis/Axes`.
//
// The templated functions are explicitly instantiated in implot_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. Vector2f), you can use striding in your ImPlotSpec.
// This is the most performant option if applicable.
//
// struct Vector2f { float X, Y; };
// ...
// Vector2f data[42];
// ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, {ImPlotProp_Stride, sizeof(Vector2f});
//
// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
// an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
// cost, but probably not enough to worry about unless your data is very large. Examples:
//
// ImPlotPoint MyDataGetter(int idx, void* data) {
// MyData* my_data = (MyData*)data;
// ImPlotPoint p;
// p.x = my_data->GetTime(idx);
// p.y = my_data->GetValue(idx);
// return p
// }
// ...
// auto my_lambda = [](int idx, void*) {
// double t = idx / 999.0;
// return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
// };
// ...
// if (ImPlot::BeginPlot("MyPlot")) {
// MyData my_data;
// ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
// ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
// ImPlot::EndPlot();
// }
//
// 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!
// Plots a standard 2D line plot.
CIMGUI_API void ImPlotPlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
CIMGUI_API void ImPlotPlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a bubble graph. #szs are the radius of each bubble in plot units.
// Plots a polygon. Points are specified in counter-clockwise order. If concave, make sure to set the Concave flag.
// Plots a a stairstep graph. The y value is continued constantly to the right from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i]
CIMGUI_API void ImPlotPlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yref to +/-INFINITY for infinite fill extents.
CIMGUI_API void ImPlotPlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a bar graph. Vertical by default. #bar_size and #shift are in plot units.
CIMGUI_API void ImPlotPlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_size, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a group of bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
// Plots stems. Vertical by default.
// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
// Plots a pie chart. Center and radius are in plot units. #label_fmt can be set to nullptr for no labels.
// Plots a 2D heatmap chart. Values are expected to be in row-major order by default. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to nullptr for no labels.
// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #range is left unspecified, the min/max of #values will be used as the range.
// Otherwise, outlier values outside of the range are not binned. The largest bin count or density is returned.
// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #range is left unspecified, the min/max of
// #xs an #ys will be used as the ranges. Otherwise, outlier values outside of range are not binned. The largest bin count or density is returned.
// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
CIMGUI_API void ImPlotPlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
#ifdef IMGUI_HAS_TEXTURES
CIMGUI_API void ImPlotPlotImage(const char* label_id, ImTextureRef tex_ref, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImVec2 uv0 /* = ImVec2(0, 0) */, ImVec2 uv1 /* = ImVec2(1, 1) */, ImVec4 tint_col /* = ImVec4(1, 1, 1, 1) */, ImPlotSpec spec /* = ImPlotSpec() */);
#else
CIMGUI_API void ImPlotPlotImage(const char* label_id, ImTextureID tex_ref, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImVec2 uv0 /* = ImVec2(0, 0) */, ImVec2 uv1 /* = ImVec2(1, 1) */, ImVec4 tint_col /* = ImVec4(1, 1, 1, 1) */, ImPlotSpec spec /* = ImPlotSpec() */);
#endif // #ifdef IMGUI_HAS_TEXTURES
// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
CIMGUI_API void ImPlotPlotText(const char* text, double x, double y, ImVec2 pix_offset /* = ImVec2(0, 0) */, ImPlotSpec spec /* = ImPlotSpec() */);
// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
CIMGUI_API void ImPlotPlotDummy(const char* label_id, ImPlotSpec spec /* = ImPlotSpec() */);
//-----------------------------------------------------------------------------
// [SECTION] Plot Tools
//-----------------------------------------------------------------------------
// The following can be used to render interactive elements and/or annotations.
// Like the item plotting functions above, they apply to the current x and y
// axes, which can be changed with `SetAxis/SetAxes`. These functions return true
// when user interaction causes the provided coordinates to change. Additional
// user interactions can be retrieved through the optional output parameters.
// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
CIMGUI_API bool ImPlotDragPoint(int id, double* x, double* y, ImVec4 col, float size /* = 4 */, ImPlotDragToolFlags flags /* = 0 */, bool* out_clicked /* = nullptr */, bool* out_hovered /* = nullptr */, bool* out_held /* = nullptr */);
// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
CIMGUI_API bool ImPlotDragLineX(int id, double* x, ImVec4 col, float thickness /* = 1 */, ImPlotDragToolFlags flags /* = 0 */, bool* out_clicked /* = nullptr */, bool* out_hovered /* = nullptr */, bool* out_held /* = nullptr */);
// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
CIMGUI_API bool ImPlotDragLineY(int id, double* y, ImVec4 col, float thickness /* = 1 */, ImPlotDragToolFlags flags /* = 0 */, bool* out_clicked /* = nullptr */, bool* out_hovered /* = nullptr */, bool* out_held /* = nullptr */);
// Shows a draggable and resizeable rectangle.
CIMGUI_API bool ImPlotDragRect(int id, double* x1, double* y1, double* x2, double* y2, ImVec4 col, ImPlotDragToolFlags flags /* = 0 */, bool* out_clicked /* = nullptr */, bool* out_hovered /* = nullptr */, bool* out_held /* = nullptr */);
// Shows an annotation callout at a chosen point. Clamping keeps annotations in the plot area. Annotations are always rendered on top.
CIMGUI_API void ImPlotAnnotation(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, bool round /* = false */);
CIMGUI_API void ImPlotAnnotationStr(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, const char* fmt, ...) IM_FMTARGS(6);
CIMGUI_API void ImPlotAnnotationStrUnformatted(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, const char* text);
CIMGUI_API void ImPlotAnnotationV(double x, double y, ImVec4 col, ImVec2 pix_offset, bool clamp, const char* fmt, va_list args) IM_FMTLIST(6);
// Shows a x-axis tag at the specified coordinate value.
CIMGUI_API void ImPlotTagX(double x, ImVec4 col, bool round /* = false */);
CIMGUI_API void ImPlotTagXStr(double x, ImVec4 col, const char* fmt, ...) IM_FMTARGS(3);
CIMGUI_API void ImPlotTagXStrUnformatted(double x, ImVec4 col, const char* text);
CIMGUI_API void ImPlotTagXV(double x, ImVec4 col, const char* fmt, va_list args) IM_FMTLIST(3);
// Shows a y-axis tag at the specified coordinate value.
CIMGUI_API void ImPlotTagY(double y, ImVec4 col, bool round /* = false */);
CIMGUI_API void ImPlotTagYStr(double y, ImVec4 col, const char* fmt, ...) IM_FMTARGS(3);
CIMGUI_API void ImPlotTagYStrUnformatted(double y, ImVec4 col, const char* text);
CIMGUI_API void ImPlotTagYV(double y, ImVec4 col, const char* fmt, va_list args) IM_FMTLIST(3);
//-----------------------------------------------------------------------------
// [SECTION] Plot Utils
//-----------------------------------------------------------------------------
// Select which axis/axes will be used for subsequent plot elements.
CIMGUI_API void ImPlotSetAxis(ImAxis axis);
CIMGUI_API void ImPlotSetAxes(ImAxis x_axis, ImAxis y_axis);
// Convert pixels to a position in the current plot's coordinate system. Passing IMPLOT_AUTO uses the current axes.
// Convert a position in the current plot's coordinate system to pixels. Passing IMPLOT_AUTO uses the current axes.
CIMGUI_API ImVec2 ImPlotPlotToPixels(ImPlotPoint plt, ImAxis x_axis /* = IMPLOT_AUTO */, ImAxis y_axis /* = IMPLOT_AUTO */);
CIMGUI_API ImVec2 ImPlotPlotToPixelsDouble(double x, double y, ImAxis x_axis /* = IMPLOT_AUTO */, ImAxis y_axis /* = IMPLOT_AUTO */);
// Get the current Plot position (top-left) in pixels.
CIMGUI_API ImVec2 ImPlotGetPlotPos(void);
// Get the current Plot size in pixels.
CIMGUI_API ImVec2 ImPlotGetPlotSize(void);
// Returns the mouse position in x,y coordinates of the current plot. Passing IMPLOT_AUTO uses the current axes.
// Returns the current plot axis range.
// Returns true if the plot area in the current plot is hovered.
CIMGUI_API bool ImPlotIsPlotHovered(void);
// Returns true if the axis label area in the current plot is hovered.
CIMGUI_API bool ImPlotIsAxisHovered(ImAxis axis);
// Returns true if the bounding frame of a subplot is hovered.
CIMGUI_API bool ImPlotIsSubplotsHovered(void);
// Returns true if the current plot is being box selected.
CIMGUI_API bool ImPlotIsPlotSelected(void);
// Returns the current plot box selection bounds. Passing IMPLOT_AUTO uses the current axes.
// Cancels a the current plot box selection.
CIMGUI_API void ImPlotCancelPlotSelection(void);
// Hides or shows the next plot item (i.e. as if it were toggled from the legend).
// Use ImPlotCond_Always if you need to forcefully set this every frame.
CIMGUI_API void ImPlotHideNextItem(bool hidden /* = true */, ImPlotCond cond /* = ImPlotCond_Once */);
// Use the following around calls to Begin/EndPlot to align l/r/t/b padding.
// Consider using Begin/EndSubplots first. They are more feature rich and
// accomplish the same behaviour by default. The functions below offer lower
// level control of plot alignment.
// Align axis padding over multiple plots in a single row or column. #group_id must
// be unique. If this function returns true, EndAlignedPlots() must be called.
CIMGUI_API bool ImPlotBeginAlignedPlots(const char* group_id, bool vertical /* = true */);
// Only call EndAlignedPlots() if BeginAlignedPlots() returns true!
CIMGUI_API void ImPlotEndAlignedPlots(void);
//-----------------------------------------------------------------------------
// [SECTION] Legend Utils
//-----------------------------------------------------------------------------
// Begin a popup for a legend entry.
CIMGUI_API bool ImPlotBeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button /* = 1 */);
// End a popup for a legend entry.
CIMGUI_API void ImPlotEndLegendPopup(void);
// Returns true if a plot item legend entry is hovered.
CIMGUI_API bool ImPlotIsLegendEntryHovered(const char* label_id);
//-----------------------------------------------------------------------------
// [SECTION] Drag and Drop
//-----------------------------------------------------------------------------
// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
CIMGUI_API bool ImPlotBeginDragDropTargetPlot(void);
// Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
CIMGUI_API bool ImPlotBeginDragDropTargetAxis(ImAxis axis);
// Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
CIMGUI_API bool ImPlotBeginDragDropTargetLegend(void);
// Ends a drag and drop target (currently just an alias for ImGui::EndDragDropTarget).
CIMGUI_API void ImPlotEndDragDropTarget(void);
// NB: By default, plot and axes drag and drop *sources* require holding the Ctrl modifier to initiate the drag.
// You can change the modifier if desired. If ImGuiMod_None is provided, the axes will be locked from panning.
// Turns the current plot's plotting area into a drag and drop source. You must hold Ctrl. Don't forget to call EndDragDropSource!
CIMGUI_API bool ImPlotBeginDragDropSourcePlot(ImGuiDragDropFlags flags /* = 0 */);
// Turns the current plot's X-axis into a drag and drop source. You must hold Ctrl. Don't forget to call EndDragDropSource!
CIMGUI_API bool ImPlotBeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags /* = 0 */);
// Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource!
CIMGUI_API bool ImPlotBeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags /* = 0 */);
// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
CIMGUI_API void ImPlotEndDragDropSource(void);
//-----------------------------------------------------------------------------
// [SECTION] Styling
//-----------------------------------------------------------------------------
// Styling colors in ImPlot works similarly to styling colors in ImGui, but
// with one important difference. Like ImGui, all style colors are stored in an
// indexable array in ImPlotStyle. You can permanently modify these values through
// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
// However, by default all style colors in ImPlot default to a special color
// IMPLOT_AUTO_COL. IMPLOT_AUTO_COL tells ImPlot to set that color from color data
// in your **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
// detailed above, and in general have been mapped to produce plots visually
// consistent with your current ImGui style. Of course, you are free to
// manually set these colors to whatever you like, and further can Push/Pop
// them around individual plots for plot-specific styling (e.g. coloring axes).
// Provides access to plot style structure for permanent modifications to colors, sizes, etc.
CIMGUI_API ImPlotStyle* ImPlotGetStyle(void);
// Style plot colors for current ImGui style (default).
CIMGUI_API void ImPlotStyleColorsAuto(ImPlotStyle* dst /* = nullptr */);
// Style plot colors for ImGui "Classic".
CIMGUI_API void ImPlotStyleColorsClassic(ImPlotStyle* dst /* = nullptr */);
// Style plot colors for ImGui "Dark".
CIMGUI_API void ImPlotStyleColorsDark(ImPlotStyle* dst /* = nullptr */);
// Style plot colors for ImGui "Light".
CIMGUI_API void ImPlotStyleColorsLight(ImPlotStyle* dst /* = nullptr */);
// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
// will last until the matching call to PopStyleX. You MUST call a pop for
// every push, otherwise you will leak memory! This behaves just like ImGui.
// Temporarily modify a style color. Don't forget to call PopStyleColor!
CIMGUI_API void ImPlotPushStyleColor(ImPlotCol idx, ImU32 col);
CIMGUI_API void ImPlotPushStyleColorImVec4(ImPlotCol idx, ImVec4 col);
// Undo temporary style color modification(s). Undo multiple pushes at once by increasing count.
CIMGUI_API void ImPlotPopStyleColor(int count /* = 1 */);
// Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
CIMGUI_API void ImPlotPushStyleVar(ImPlotStyleVar idx, float val);
// Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
CIMGUI_API void ImPlotPushStyleVarInt(ImPlotStyleVar idx, int val);
// Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
CIMGUI_API void ImPlotPushStyleVarImVec2(ImPlotStyleVar idx, ImVec2 val);
// Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
CIMGUI_API void ImPlotPopStyleVar(int count /* = 1 */);
// Gets the last item primary color (i.e. its legend icon color)
CIMGUI_API ImVec4 ImPlotGetLastItemColor(void);
// Returns the null terminated string name for an ImPlotCol.
CIMGUI_API const char* ImPlotGetStyleColorName(ImPlotCol idx);
// Returns the null terminated string name for an ImPlotMarker.
CIMGUI_API const char* ImPlotGetMarkerName(ImPlotMarker idx);
// Returns the next marker and advances the marker for the current plot. You need to call this between Begin/EndPlot!
CIMGUI_API ImPlotMarker ImPlotNextMarker(void);
//-----------------------------------------------------------------------------
// [SECTION] Colormaps
//-----------------------------------------------------------------------------
// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
// IMPLOT_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 ImPlotStyle.
// 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 ImPlotStyle to anything other than IMPLOT_AUTO_COL.
// 2) Pushed an item style color using PushStyleColor().
// 3) Set the next item style with a SetNextXXXStyle function.
// 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 ImPlot will build a linearly
// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
CIMGUI_API ImPlotColormap ImPlotAddColormap(const char* name, const ImVec4* cols, int size, bool qual /* = true */);
CIMGUI_API ImPlotColormap ImPlotAddColormapImU32Ptr(const char* name, const ImU32* cols, int size, bool qual /* = true */);
// Returns the number of available colormaps (i.e. the built-in + user-added count).
CIMGUI_API int ImPlotGetColormapCount(void);
// Returns a null terminated string name for a colormap given an index. Returns nullptr if index is invalid.
CIMGUI_API const char* ImPlotGetColormapName(ImPlotColormap cmap);
// Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid.
CIMGUI_API ImPlotColormap ImPlotGetColormapIndex(const char* name);
// Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
CIMGUI_API void ImPlotPushColormap(ImPlotColormap cmap);
// Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
CIMGUI_API void ImPlotPushColormapStr(const char* name);
// Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
CIMGUI_API void ImPlotPopColormap(int count /* = 1 */);
// 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 this between Begin/EndPlot!
CIMGUI_API ImVec4 ImPlotNextColormapColor(void);
// Colormap utils. If cmap = IMPLOT_AUTO (default), the current colormap is assumed.
// Pass an explicit colormap index (built-in or user-added) to specify otherwise.
// Returns the size of a colormap.
CIMGUI_API int ImPlotGetColormapSize(ImPlotColormap cmap /* = IMPLOT_AUTO */);
// Returns a color from a colormap given an index >= 0 (modulo will be performed).
CIMGUI_API ImVec4 ImPlotGetColormapColor(int idx, ImPlotColormap cmap /* = IMPLOT_AUTO */);
// Sample a color from the current colormap given t between 0 and 1.
CIMGUI_API ImVec4 ImPlotSampleColormap(float t, ImPlotColormap cmap /* = IMPLOT_AUTO */);
// Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel"). If scale_min > scale_max, the scale to color mapping will be reversed.
CIMGUI_API void ImPlotColormapScale(const char* label, double scale_min, double scale_max, ImVec2 size /* = ImVec2(0, 0) */, const char* format /* = "%g" */, ImPlotColormapScaleFlags flags /* = 0 */, ImPlotColormap cmap /* = IMPLOT_AUTO */);
// Shows a horizontal slider with a colormap gradient background. Optionally returns the color sampled at t in [0 1].
CIMGUI_API bool ImPlotColormapSlider(const char* label, float* t, ImVec4* out /* = nullptr */, const char* format /* = "" */, ImPlotColormap cmap /* = IMPLOT_AUTO */);
// Shows a button with a colormap gradient background.
CIMGUI_API bool ImPlotColormapButton(const char* label, ImVec2 size /* = ImVec2(0, 0) */, ImPlotColormap cmap /* = IMPLOT_AUTO */);
// When items in a plot sample their color from a colormap, the color is cached and does not change
// unless explicitly overridden. Therefore, if you change the colormap after the item has already been plotted,
// item colors will NOT update. If you need item colors to resample the new colormap, then use this
// function to bust the cached colors. If #plot_title_id is nullptr, then every item in EVERY existing plot
// will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
// latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
// need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
CIMGUI_API void ImPlotBustColorCache(const char* plot_title_id /* = nullptr */);
//-----------------------------------------------------------------------------
// [SECTION] Input Mapping
//-----------------------------------------------------------------------------
// Provides access to input mapping structure for permanent modifications to controls for pan, select, etc.
CIMGUI_API ImPlotInputMap* ImPlotGetInputMap(void);
// Default input mapping: pan = LMB drag, box select = RMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
CIMGUI_API void ImPlotMapInputDefault(ImPlotInputMap* dst /* = nullptr */);
// Reverse input mapping: pan = RMB drag, box select = LMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
CIMGUI_API void ImPlotMapInputReverse(ImPlotInputMap* dst /* = nullptr */);
//-----------------------------------------------------------------------------
// [SECTION] Miscellaneous
//-----------------------------------------------------------------------------
// Render icons similar to those that appear in legends (nifty for data lists).
CIMGUI_API void ImPlotItemIcon(ImVec4 col);
CIMGUI_API void ImPlotItemIconImU32(ImU32 col);
CIMGUI_API void ImPlotColormapIcon(ImPlotColormap cmap);
// Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
CIMGUI_API ImDrawList* ImPlotGetPlotDrawList(void);
// Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
CIMGUI_API void ImPlotPushPlotClipRect(float expand /* = 0 */);
// Pop plot clip rect. Call between Begin/EndPlot.
CIMGUI_API void ImPlotPopPlotClipRect(void);
// Shows ImPlot style selector dropdown menu.
CIMGUI_API bool ImPlotShowStyleSelector(const char* label);
// Shows ImPlot colormap selector dropdown menu.
CIMGUI_API bool ImPlotShowColormapSelector(const char* label);
// Shows ImPlot input map selector dropdown menu.
CIMGUI_API bool ImPlotShowInputMapSelector(const char* label);
// Shows ImPlot style editor block (not a window).
CIMGUI_API void ImPlotShowStyleEditor(ImPlotStyle* ref /* = nullptr */);
// Add basic help/info block for end users (not a window).
CIMGUI_API void ImPlotShowUserGuide(void);
// Shows ImPlot metrics/debug information window.
CIMGUI_API void ImPlotShowMetricsWindow(bool* p_popen /* = nullptr */);
//-----------------------------------------------------------------------------
// [SECTION] Demo
//-----------------------------------------------------------------------------
// Shows the ImPlot demo window (add implot_demo.cpp to your sources!)
//-----------------------------------------------------------------------------
// [SECTION] Obsolete API
//-----------------------------------------------------------------------------
// The following functions will be removed! Keep your copy of implot up to date!
// Occasionally set '#define IMPLOT_DISABLE_OBSOLETE_FUNCTIONS' to stay ahead.
// If you absolutely must use these functions and do not want to receive compiler
// warnings, set '#define IMPLOT_DISABLE_OBSOLETE_WARNINGS'.
#ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
#ifndef IMPLOT_DISABLE_DEPRECATED_WARNINGS
#if __cplusplus>201402L
#define IMPLOT_DEPRECATED(method) [[deprecated]] method
#else
#if defined(__GNUC__)&&!defined(__INTEL_COMPILER)&&(__GNUC__>3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
#define IMPLOT_DEPRECATED(method) method __attribute__( ( deprecated ) )
#else
#if defined(_MSC_VER)
#define IMPLOT_DEPRECATED(method) __declspec(deprecated) method
#else
#define IMPLOT_DEPRECATED(method) method
#endif // #if defined(_MSC_VER)
#endif // #if defined(__GNUC__)&&!defined(__INTEL_COMPILER)&&(__GNUC__>3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
#endif // #if __cplusplus>201402L
#else
#define IMPLOT_DEPRECATED(method) method
#endif // #ifndef IMPLOT_DISABLE_DEPRECATED_WARNINGS
// OBSOLETED in v1.0 (from February 2026)
// IMGUI_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO); // OBSOLETED IN v1.0 // Set ImPlotSpec.LineColor/LineWeight or construct ImPlotSpec with { ImPlotSpec_LineColor, color, ImPlotSpec_LineWeight, weight }.
// IMGUI_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);// OBSOLETED IN v1.0 // Set ImPlotSpec.FillColor/FillAlpha or construct ImPlotSpec with { ImPlotSpec_FillColor, color, ImPlotSpec_FillAlpha, alpha }.
// IMGUI_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL); // OBSOLETED IN v1.0 // Set ImPlotSpec.Marker/MarkerSize/MarkerFillColor/LineWeight/MarkerLineColor or construct ImPlotSpec with { ImPlotSpec_Marker, marker, ImPlotSpec_MarkerSize, size, ImPlotSpec_MarkerFillColor, fill_color, ImPlotSpec_LineWeight, weight, ImPlotSpec_MarkerLineColor, outline }.
// IMGUI_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO); // OBSOLETED IN v1.0 // Set ImPlotSpec.LineColor/Size/LineWeight or construct ImPlotSpec with { ImPlotSpec_LineColor, col, ImPlotSpec_Size, size, ImPlotSpec_LineWeight, weight }.
#endif// #ifndef IMPLOT_DISABLE_OBSOLETE_FUNCTIONS
#endif// #ifndef IMGUI_DISABLE
// THIS FILE HAS BEEN AUTO-GENERATED BY scripts/generate-implot-shim.py.
// **DO NOT EDIT DIRECTLY** -- regen via scripts/refresh-generated-in.sh.
//
// Monomorphized shim for implot's templated public API. Each
// IMPLOT_TMP-fronted PlotXxx<T> in upstream's implot.h becomes
// 10 concrete entry points here, one per scalar type that
// implot_items.cpp explicitly instantiates. Disambiguation infix:
// <Name>_<Tag> single-overload functions
// <Name>_xy_<Tag> (xs, ys) form
// <Name>_xyy_<Tag> (xs, ys1, ys2) form
// <Name>_xye_<Tag> (xs, ys, err) form
// <Name>_xynp_<Tag> (xs, ys, neg, pos) form
// PlotPieChart_fmt_<Tag> formatter-callback overload
CIMGUI_API void ImPlotPlotLine_S8(const char* label_id, const ImS8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_U8(const char* label_id, const ImU8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_S16(const char* label_id, const ImS16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_U16(const char* label_id, const ImU16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_S32(const char* label_id, const ImS32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_U32(const char* label_id, const ImU32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_S64(const char* label_id, const ImS64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_U64(const char* label_id, const ImU64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_F32(const char* label_id, const float* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_F64(const char* label_id, const double* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_F32(const char* label_id, const float* xs, const float* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotLine_xy_F64(const char* label_id, const double* xs, const double* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_S8(const char* label_id, const ImS8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_U8(const char* label_id, const ImU8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_S16(const char* label_id, const ImS16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_U16(const char* label_id, const ImU16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_S32(const char* label_id, const ImS32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_U32(const char* label_id, const ImU32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_S64(const char* label_id, const ImS64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_U64(const char* label_id, const ImU64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_F32(const char* label_id, const float* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_F64(const char* label_id, const double* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_F32(const char* label_id, const float* xs, const float* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotScatter_xy_F64(const char* label_id, const double* xs, const double* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_S8(const char* label_id, const ImS8* values, const ImS8* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_U8(const char* label_id, const ImU8* values, const ImU8* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_S16(const char* label_id, const ImS16* values, const ImS16* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_U16(const char* label_id, const ImU16* values, const ImU16* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_S32(const char* label_id, const ImS32* values, const ImS32* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_U32(const char* label_id, const ImU32* values, const ImU32* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_S64(const char* label_id, const ImS64* values, const ImS64* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_U64(const char* label_id, const ImU64* values, const ImU64* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_F32(const char* label_id, const float* values, const float* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_F64(const char* label_id, const double* values, const double* szs, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_F32(const char* label_id, const float* xs, const float* ys, const float* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBubbles_xy_F64(const char* label_id, const double* xs, const double* ys, const double* szs, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_F32(const char* label_id, const float* xs, const float* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPolygon_F64(const char* label_id, const double* xs, const double* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_S8(const char* label_id, const ImS8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_U8(const char* label_id, const ImU8* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_S16(const char* label_id, const ImS16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_U16(const char* label_id, const ImU16* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_S32(const char* label_id, const ImS32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_U32(const char* label_id, const ImU32* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_S64(const char* label_id, const ImS64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_U64(const char* label_id, const ImU64* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_F32(const char* label_id, const float* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_F64(const char* label_id, const double* values, int count, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_F32(const char* label_id, const float* xs, const float* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStairs_xy_F64(const char* label_id, const double* xs, const double* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_S8(const char* label_id, const ImS8* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_U8(const char* label_id, const ImU8* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_S16(const char* label_id, const ImS16* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_U16(const char* label_id, const ImU16* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_S32(const char* label_id, const ImS32* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_U32(const char* label_id, const ImU32* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_S64(const char* label_id, const ImS64* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_U64(const char* label_id, const ImU64* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_F32(const char* label_id, const float* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_F64(const char* label_id, const double* values, int count, double yref, double xscale, double xstart, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_F32(const char* label_id, const float* xs, const float* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xy_F64(const char* label_id, const double* xs, const double* ys, int count, double yref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_S8(const char* label_id, const ImS8* xs, const ImS8* ys1, const ImS8* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_U8(const char* label_id, const ImU8* xs, const ImU8* ys1, const ImU8* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_S16(const char* label_id, const ImS16* xs, const ImS16* ys1, const ImS16* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_U16(const char* label_id, const ImU16* xs, const ImU16* ys1, const ImU16* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_S32(const char* label_id, const ImS32* xs, const ImS32* ys1, const ImS32* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_U32(const char* label_id, const ImU32* xs, const ImU32* ys1, const ImU32* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_S64(const char* label_id, const ImS64* xs, const ImS64* ys1, const ImS64* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_U64(const char* label_id, const ImU64* xs, const ImU64* ys1, const ImU64* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_F32(const char* label_id, const float* xs, const float* ys1, const float* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotShaded_xyy_F64(const char* label_id, const double* xs, const double* ys1, const double* ys2, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_S8(const char* label_id, const ImS8* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_U8(const char* label_id, const ImU8* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_S16(const char* label_id, const ImS16* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_U16(const char* label_id, const ImU16* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_S32(const char* label_id, const ImS32* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_U32(const char* label_id, const ImU32* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_S64(const char* label_id, const ImS64* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_U64(const char* label_id, const ImU64* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_F32(const char* label_id, const float* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_F64(const char* label_id, const double* values, int count, double bar_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_F32(const char* label_id, const float* xs, const float* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBars_xy_F64(const char* label_id, const double* xs, const double* ys, int count, double bar_size, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_S8(const char*const label_ids[], const ImS8* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_U8(const char*const label_ids[], const ImU8* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_S16(const char*const label_ids[], const ImS16* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_U16(const char*const label_ids[], const ImU16* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_S32(const char*const label_ids[], const ImS32* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_U32(const char*const label_ids[], const ImU32* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_S64(const char*const label_ids[], const ImS64* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_U64(const char*const label_ids[], const ImU64* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_F32(const char*const label_ids[], const float* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotBarGroups_F64(const char*const label_ids[], const double* values, int item_count, int group_count, double group_size, double shift, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_S8(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_U8(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_S16(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_U16(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_S32(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_U32(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_S64(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_U64(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_F32(const char* label_id, const float* xs, const float* ys, const float* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xye_F64(const char* label_id, const double* xs, const double* ys, const double* err, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_S8(const char* label_id, const ImS8* xs, const ImS8* ys, const ImS8* neg, const ImS8* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_U8(const char* label_id, const ImU8* xs, const ImU8* ys, const ImU8* neg, const ImU8* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_S16(const char* label_id, const ImS16* xs, const ImS16* ys, const ImS16* neg, const ImS16* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_U16(const char* label_id, const ImU16* xs, const ImU16* ys, const ImU16* neg, const ImU16* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_S32(const char* label_id, const ImS32* xs, const ImS32* ys, const ImS32* neg, const ImS32* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_U32(const char* label_id, const ImU32* xs, const ImU32* ys, const ImU32* neg, const ImU32* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_S64(const char* label_id, const ImS64* xs, const ImS64* ys, const ImS64* neg, const ImS64* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_U64(const char* label_id, const ImU64* xs, const ImU64* ys, const ImU64* neg, const ImU64* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_F32(const char* label_id, const float* xs, const float* ys, const float* neg, const float* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotErrorBars_xynp_F64(const char* label_id, const double* xs, const double* ys, const double* neg, const double* pos, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_S8(const char* label_id, const ImS8* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_U8(const char* label_id, const ImU8* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_S16(const char* label_id, const ImS16* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_U16(const char* label_id, const ImU16* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_S32(const char* label_id, const ImS32* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_U32(const char* label_id, const ImU32* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_S64(const char* label_id, const ImS64* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_U64(const char* label_id, const ImU64* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_F32(const char* label_id, const float* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_F64(const char* label_id, const double* values, int count, double ref, double scale, double start, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_F32(const char* label_id, const float* xs, const float* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotStems_xy_F64(const char* label_id, const double* xs, const double* ys, int count, double ref, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_S8(const char* label_id, const ImS8* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_U8(const char* label_id, const ImU8* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_S16(const char* label_id, const ImS16* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_U16(const char* label_id, const ImU16* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_S32(const char* label_id, const ImS32* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_U32(const char* label_id, const ImU32* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_S64(const char* label_id, const ImS64* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_U64(const char* label_id, const ImU64* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_F32(const char* label_id, const float* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotInfLines_F64(const char* label_id, const double* values, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_S8(const char*const label_ids[], const ImS8* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_U8(const char*const label_ids[], const ImU8* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_S16(const char*const label_ids[], const ImS16* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_U16(const char*const label_ids[], const ImU16* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_S32(const char*const label_ids[], const ImS32* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_U32(const char*const label_ids[], const ImU32* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_S64(const char*const label_ids[], const ImS64* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_U64(const char*const label_ids[], const ImU64* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_F32(const char*const label_ids[], const float* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_fmt_F64(const char*const label_ids[], const double* values, int count, double x, double y, double radius, ImPlotFormatter fmt, void* fmt_data, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_S8(const char*const label_ids[], const ImS8* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_U8(const char*const label_ids[], const ImU8* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_S16(const char*const label_ids[], const ImS16* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_U16(const char*const label_ids[], const ImU16* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_S32(const char*const label_ids[], const ImS32* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_U32(const char*const label_ids[], const ImU32* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_S64(const char*const label_ids[], const ImS64* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_U64(const char*const label_ids[], const ImU64* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_F32(const char*const label_ids[], const float* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotPieChart_F64(const char*const label_ids[], const double* values, int count, double x, double y, double radius, const char* label_fmt, double angle0, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_S8(const char* label_id, const ImS8* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_U8(const char* label_id, const ImU8* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_S16(const char* label_id, const ImS16* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_U16(const char* label_id, const ImU16* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_S32(const char* label_id, const ImS32* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_U32(const char* label_id, const ImU32* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_S64(const char* label_id, const ImS64* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_U64(const char* label_id, const ImU64* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_F32(const char* label_id, const float* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotHeatmap_F64(const char* label_id, const double* values, int rows, int cols, double scale_min, double scale_max, const char* label_fmt, ImPlotPoint bounds_min, ImPlotPoint bounds_max, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_S8(const char* label_id, const ImS8* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_U8(const char* label_id, const ImU8* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_S16(const char* label_id, const ImS16* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_U16(const char* label_id, const ImU16* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_S32(const char* label_id, const ImS32* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_U32(const char* label_id, const ImU32* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_S64(const char* label_id, const ImS64* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_U64(const char* label_id, const ImU64* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_F32(const char* label_id, const float* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram_F64(const char* label_id, const double* values, int count, int bins, double bar_scale, ImPlotRange range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_F32(const char* label_id, const float* xs, const float* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API double ImPlotPlotHistogram2D_F64(const char* label_id, const double* xs, const double* ys, int count, int x_bins, int y_bins, ImPlotRect range, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_S8(const char* label_id, const ImS8* xs, const ImS8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_U8(const char* label_id, const ImU8* xs, const ImU8* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_S16(const char* label_id, const ImS16* xs, const ImS16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_U16(const char* label_id, const ImU16* xs, const ImU16* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_S32(const char* label_id, const ImS32* xs, const ImS32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_U32(const char* label_id, const ImU32* xs, const ImU32* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_S64(const char* label_id, const ImS64* xs, const ImS64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_U64(const char* label_id, const ImU64* xs, const ImU64* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_F32(const char* label_id, const float* xs, const float* ys, int count, ImPlotSpec spec);
CIMGUI_API void ImPlotPlotDigital_F64(const char* label_id, const double* xs, const double* ys, int count, ImPlotSpec spec);
#ifdef __cplusplus
} // End of extern "C" block
#endif