mirror of
https://github.com/gwm17/implot.git
synced 2024-11-22 18:28:53 -05:00
Features/item flags (#319)
* add PlotBarGroups and layout some plans for flags * exprimentin * item flags added to each plotter * rendering templates * rendering templates * item flags and axis scales * item flags * template markers * markers * benching * buffer * inline adjust * inline fix * dunno * fix some todos * tickers * clean up * update TODO * update breaking changes * demo cleanup * remove TODO label * header cleanup
This commit is contained in:
Evan Pezent
GitHub
parent
79b05d5e25
commit
63d5ed94b7
44
TODO.md
44
TODO.md
|
|
@ -2,36 +2,32 @@ The list below represents a combination of high-priority work, nice-to-have feat
|
|||
|
||||
## API
|
||||
|
||||
- add shortcut/legacy overloads for BeginPlot
|
||||
|
||||
## Axes
|
||||
|
||||
- add flag to remove weekends on Time axis
|
||||
- pixel space scale (`ImPlotTransform_Display`), normalized space scale (`ImPlotTransform_Axes`), data space scale (`ImPloTransform_Data`)
|
||||
- pixel space scale (`ImPlotTransform_Display`), normalized space scale (`ImPlotTransform_Axes`), data space scale (`ImPlotTransform_Data`)
|
||||
- make ImPlotFlags_Equal not a flag -> `SetupEqual(ImPlotAxis x, ImPlotAxis y)`
|
||||
- allow inverted arguments `SetAxes` to transpose data?
|
||||
- `SetupAxisColors()`
|
||||
- `SetupAxisConstraints()`
|
||||
- `SetupAxisHome()`
|
||||
|
||||
## Plot Items
|
||||
|
||||
- add `ImPlotLineFlags`, `ImPlotBarsFlags`, etc. for each plot type
|
||||
- add `PlotBarGroups` wrapper that makes rendering groups of bars easier, with stacked bar support
|
||||
- add `PlotBubbles` (see MATLAB bubble chart)
|
||||
- add non-zero references for `PlotBars` etc.
|
||||
- add exploding to `PlotPieChart` (on hover-highlight?)
|
||||
- fix appearance of `PlotBars` spacing
|
||||
|
||||
## Styling
|
||||
|
||||
- support gradient and/or colormap sampled fills (e.g. ImPlotFillStyle_)
|
||||
- add hover/active color for plot axes
|
||||
- API for setting different fonts for plot elements
|
||||
|
||||
## Colormaps
|
||||
|
||||
- gradient editing tool
|
||||
- `RemoveColormap`
|
||||
- `enum ImPlotColorRule_ { Solid, Faded, XValue, YValue, ZValue }`
|
||||
|
||||
## Legend
|
||||
|
||||
|
|
@ -48,6 +44,7 @@ The list below represents a combination of high-priority work, nice-to-have feat
|
|||
- add box selection to axes
|
||||
- first frame render delay might fix "fit pop" effect
|
||||
- move some code to new `implot_tools.cpp`
|
||||
- ColormapSlider (see metrics)
|
||||
|
||||
## Optimizations
|
||||
|
||||
|
|
@ -55,6 +52,32 @@ The list below represents a combination of high-priority work, nice-to-have feat
|
|||
- reduce number of calls to `PushClipRect`
|
||||
- explore SIMD operations for high density plot items
|
||||
|
||||
## Plotter Pipeline
|
||||
|
||||
Ideally every `PlotX` function should use our faster rendering pipeline when it is applicable.
|
||||
|
||||
` User Data > Getter > Fitter > Renderer > RenderPrimitives`
|
||||
|
||||
|Plotter|Getter|Fitter|Renderer|RenderPrimitives|
|
||||
|---|:-:|:-:|:-:|:-:|
|
||||
|PlotLine|Yes|Yes|Yes|Yes|
|
||||
|PlotScatter|Yes|Yes|Yes|Yes|
|
||||
|PlotStairs|Yes|Yes|Yes|Yes|
|
||||
|PlotShaded|Yes|Yes|Yes|Yes|
|
||||
|PlotBars|Yes|Yes|Yes|Yes|
|
||||
|PlotBarGroups|:|:|:|:|
|
||||
|PlotHistogram|:|:|:|:|
|
||||
|PlotErrorBars|Yes|Yes|No|No|
|
||||
|PlotStems|Yes|Yes|Yes|Yes|
|
||||
|PlotInfLines|Yes|Yes|Yes|Yes|
|
||||
|PlotPieChart|No|No|No|No|
|
||||
|PlotHeatmap|Yes|No|Yes|Mixed|
|
||||
|PlotHistogram2D|:|:|:|:|
|
||||
|PlotDigital|Yes|No|No|No|
|
||||
|PlotImage|-|-|-|-|
|
||||
|PlotText|-|-|-|-|
|
||||
|PlotDummy|-|-|-|-|
|
||||
|
||||
## Completed
|
||||
- make BeginPlot take fewer args:
|
||||
- make query a tool -> `DragRect`
|
||||
|
|
@ -67,3 +90,10 @@ The list below represents a combination of high-priority work, nice-to-have feat
|
|||
- legend items can be hovered even if plot is not
|
||||
- fix frame delay on DragX tools
|
||||
- remove tag from drag line/point -> add `Tag` tool
|
||||
- add shortcut/legacy overloads for BeginPlot
|
||||
- `SetupAxisConstraints()`
|
||||
- `SetupAxisScale()`
|
||||
- add `ImPlotLineFlags`, `ImPlotBarsFlags`, etc. for each plot type
|
||||
- add `PlotBarGroups` wrapper that makes rendering groups of bars easier, with stacked bar support
|
||||
- `PlotBars` restore outlines
|
||||
- add hover/active color for plot axes
|
||||
|
|
|
|||
638
implot.cpp
638
implot.cpp
File diff suppressed because it is too large
Load Diff
332
implot.h
332
implot.h
|
|
@ -1,6 +1,6 @@
|
|||
// MIT License
|
||||
|
||||
// Copyright (c) 2021 Evan Pezent
|
||||
// Copyright (c) 2022 Evan Pezent
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
// ImPlot v0.13 WIP
|
||||
// ImPlot v0.14
|
||||
|
||||
// Table of Contents:
|
||||
//
|
||||
|
|
@ -60,7 +60,7 @@
|
|||
#endif
|
||||
|
||||
// ImPlot version string.
|
||||
#define IMPLOT_VERSION "0.13 WIP"
|
||||
#define IMPLOT_VERSION "0.14"
|
||||
// Indicates variable should deduced automatically.
|
||||
#define IMPLOT_AUTO -1
|
||||
// Special color used to indicate that a color should be deduced automatically.
|
||||
|
|
@ -83,11 +83,29 @@ typedef int ImPlotSubplotFlags; // -> enum ImPlotSubplotFlags_
|
|||
typedef int ImPlotLegendFlags; // -> enum ImPlotLegendFlags_
|
||||
typedef int ImPlotMouseTextFlags; // -> enum ImPlotMouseTextFlags_
|
||||
typedef int ImPlotDragToolFlags; // -> ImPlotDragToolFlags_
|
||||
|
||||
typedef int ImPlotItemFlags; // -> ImPlotItemFlags_
|
||||
typedef int ImPlotLineFlags; // -> ImPlotLineFlags_
|
||||
typedef int ImPlotScatterFlags; // -> ImPlotScatterFlags
|
||||
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_
|
||||
|
|
@ -120,7 +138,6 @@ enum ImPlotFlags_ {
|
|||
ImPlotFlags_NoFrame = 1 << 7, // the ImGui frame will not be rendered
|
||||
ImPlotFlags_Equal = 1 << 8, // x and y axes pairs will be constrained to have the same units/pixel
|
||||
ImPlotFlags_Crosshairs = 1 << 9, // the default mouse cursor will be replaced with a crosshair when hovered
|
||||
ImPlotFlags_AntiAliased = 1 << 10, // plot items will be software anti-aliased (not recommended for high density plots, prefer MSAA)
|
||||
ImPlotFlags_CanvasOnly = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText
|
||||
};
|
||||
|
||||
|
|
@ -133,15 +150,14 @@ enum ImPlotAxisFlags_ {
|
|||
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_Opposite = 1 << 6, // axis ticks and labels will be rendered on conventionally opposite side (i.e, right or top)
|
||||
ImPlotAxisFlags_Opposite = 1 << 6, // axis ticks and labels will be rendered on the conventionally opposite side (i.e, right or top)
|
||||
ImPlotAxisFlags_Foreground = 1 << 7, // grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
|
||||
ImPlotAxisFlags_LogScale = 1 << 8, // a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time)
|
||||
ImPlotAxisFlags_Time = 1 << 9, // axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale)
|
||||
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_LockMin = 1 << 13, // the axis minimum value will be locked when panning/zooming
|
||||
ImPlotAxisFlags_LockMax = 1 << 14, // the axis maximum value will be locked when panning/zooming
|
||||
ImPlotAxisFlags_Invert = 1 << 8, // the axis will be inverted
|
||||
ImPlotAxisFlags_AutoFit = 1 << 9, // axis will be auto-fitting to data extents
|
||||
ImPlotAxisFlags_RangeFit = 1 << 10, // axis will only fit points if the point is in the visible range of the **orthogonal** axis
|
||||
ImPlotAxisFlags_PanStretch = 1 << 11, // panning in a locked or constrained state will cause the axis to stretch if possible
|
||||
ImPlotAxisFlags_LockMin = 1 << 12, // the axis minimum value will be locked when panning/zooming
|
||||
ImPlotAxisFlags_LockMax = 1 << 13, // 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
|
||||
|
|
@ -191,10 +207,111 @@ enum ImPlotDragToolFlags_ {
|
|||
ImPlotDragToolFlags_Delayed = 1 << 3, // tool rendering will be delayed one frame; useful when applying position-constraints
|
||||
};
|
||||
|
||||
// Flags for ImPlot::PlotBarGroups
|
||||
// Flags for ANY PlotX function
|
||||
enum ImPlotItemFlags_ {
|
||||
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
|
||||
};
|
||||
|
||||
// Flags for PlotLine
|
||||
enum ImPlotLineFlags_ {
|
||||
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
|
||||
};
|
||||
|
||||
// Flags for PlotScatter
|
||||
enum ImPlotScatterFlags_ {
|
||||
ImPlotScatterFlags_None = 0, // default
|
||||
ImPlotScatterFlags_NoClip = 1 << 10, // markers on the edge of a plot will not be clipped
|
||||
};
|
||||
|
||||
// Flags for PlotStairs
|
||||
enum ImPlotStairsFlags_ {
|
||||
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]
|
||||
};
|
||||
|
||||
// Flags for PlotShaded (placeholder)
|
||||
enum ImPlotShadedFlags_ {
|
||||
ImPlotShadedFlags_None = 0 // default
|
||||
};
|
||||
|
||||
// Flags for PlotBars
|
||||
enum ImPlotBarsFlags_ {
|
||||
ImPlotBarsFlags_None = 0, // default
|
||||
ImPlotBarsFlags_Horizontal = 1 << 10, // bars will be rendered horizontally on the current y-axis
|
||||
};
|
||||
|
||||
// Flags for PlotBarGroups
|
||||
enum ImPlotBarGroupsFlags_ {
|
||||
ImPlotBarGroupsFlags_None = 0, // default
|
||||
ImPlotBarGroupsFlags_Stacked = 1 << 0, // items in a group will be stacked on top of each other
|
||||
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
|
||||
};
|
||||
|
||||
// Flags for PlotErrorBars
|
||||
enum ImPlotErrorBarsFlags_ {
|
||||
ImPlotErrorBarsFlags_None = 0, // default
|
||||
ImPlotErrorBarsFlags_Horizontal = 1 << 10, // error bars will be rendered horizontally on the current y-axis
|
||||
};
|
||||
|
||||
// Flags for PlotStems
|
||||
enum ImPlotStemsFlags_ {
|
||||
ImPlotStemsFlags_None = 0, // default
|
||||
ImPlotStemsFlags_Horizontal = 1 << 10, // stems will be rendered horizontally on the current y-axis
|
||||
};
|
||||
|
||||
// Flags for PlotInfLines
|
||||
enum ImPlotInfLinesFlags_ {
|
||||
ImPlotInfLinesFlags_None = 0, // default
|
||||
ImPlotInfLinesFlags_Horizontal = 1 << 10 // lines will be rendered horizontally on the current y-axis
|
||||
};
|
||||
|
||||
// Flags for PlotPieChart
|
||||
enum ImPlotPieChartFlags_ {
|
||||
ImPlotPieChartFlags_None = 0, // default
|
||||
ImPlotPieChartFlags_Normalize = 1 << 10 // force normalization of pie chart values (i.e. always make a full circle if sum < 0)
|
||||
};
|
||||
|
||||
// Flags for PlotHeatmap
|
||||
enum ImPlotHeatmapFlags_ {
|
||||
ImPlotHeatmapFlags_None = 0, // default
|
||||
ImPlotHeatmapFlags_ColMajor = 1 << 10, // data will be read in column major order
|
||||
};
|
||||
|
||||
// Flags for PlotHistogram and PlotHistogram2D
|
||||
enum ImPlotHistogramFlags_ {
|
||||
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 specifed 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)
|
||||
};
|
||||
|
||||
// Flags for PlotDigital (placeholder)
|
||||
enum ImPlotDigitalFlags_ {
|
||||
ImPlotDigitalFlags_None = 0 // default
|
||||
};
|
||||
|
||||
// Flags for PlotImage (placeholder)
|
||||
enum ImPlotImageFlags_ {
|
||||
ImPlotImageFlags_None = 0 // default
|
||||
};
|
||||
|
||||
// Flags for PlotText
|
||||
enum ImPlotTextFlags_ {
|
||||
ImPlotTextFlags_None = 0, // default
|
||||
ImPlotTextFlags_Vertical = 1 << 10 // text will be rendered vertically
|
||||
};
|
||||
|
||||
// Flags for PlotDummy (placeholder)
|
||||
enum ImPlotDummyFlags_ {
|
||||
ImPlotDummyFlags_None = 0 // default
|
||||
};
|
||||
|
||||
// Represents a condition for SetupAxisLimits etc. (same as ImGuiCond, but we only support a subset of those enums)
|
||||
|
|
@ -267,10 +384,18 @@ enum ImPlotStyleVar_ {
|
|||
ImPlotStyleVar_COUNT
|
||||
};
|
||||
|
||||
// Axis scale
|
||||
enum ImPlotScale_ {
|
||||
ImPlotScale_Linear = 0, // default linear scale
|
||||
ImPlotScale_Time, // date/time scale
|
||||
ImPlotScale_Log10, // base 10 logartithmic scale
|
||||
ImPlotScale_SymLog, // symmetric log scale
|
||||
};
|
||||
|
||||
// Marker specifications.
|
||||
enum ImPlotMarker_ {
|
||||
ImPlotMarker_None = -1, // no marker
|
||||
ImPlotMarker_Circle, // a circle marker
|
||||
ImPlotMarker_Circle, // a circle marker (default)
|
||||
ImPlotMarker_Square, // a square maker
|
||||
ImPlotMarker_Diamond, // a diamond marker
|
||||
ImPlotMarker_Up, // an upward-pointing triangle marker
|
||||
|
|
@ -398,7 +523,6 @@ struct ImPlotStyle {
|
|||
// colormap
|
||||
ImPlotColormap Colormap; // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
|
||||
// settings/flags
|
||||
bool AntiAliasedLines; // = false, enable global anti-aliasing on plot lines (overrides ImPlotFlags_AntiAliased)
|
||||
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
|
||||
|
|
@ -436,10 +560,13 @@ struct ImPlotInputMap {
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Callback signature for axis tick label formatter.
|
||||
typedef void (*ImPlotFormatter)(double value, char* buff, int size, void* user_data);
|
||||
typedef int (*ImPlotFormatter)(double value, char* buff, int size, void* user_data);
|
||||
|
||||
// Callback signature for data getter.
|
||||
typedef ImPlotPoint (*ImPlotGetter)(void* user_data, int idx);
|
||||
typedef ImPlotPoint (*ImPlotGetter)(int idx, void* user_data);
|
||||
|
||||
// Callback signature for axis transform.
|
||||
typedef double (*ImPlotTransform)(double value, void* user_data);
|
||||
|
||||
namespace ImPlot {
|
||||
|
||||
|
|
@ -482,7 +609,7 @@ IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
|
|||
// (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.
|
||||
IMPLOT_API bool BeginPlot(const char* title_id, const ImVec2& size = ImVec2(-1,0), ImPlotFlags flags = ImPlotFlags_None);
|
||||
IMPLOT_API bool BeginPlot(const char* title_id, const 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.
|
||||
|
|
@ -542,7 +669,7 @@ IMPLOT_API bool BeginSubplots(const char* title_id,
|
|||
int rows,
|
||||
int cols,
|
||||
const ImVec2& size,
|
||||
ImPlotSubplotFlags flags = ImPlotSubplotFlags_None,
|
||||
ImPlotSubplotFlags flags = 0,
|
||||
float* row_ratios = NULL,
|
||||
float* col_ratios = NULL);
|
||||
|
||||
|
|
@ -580,7 +707,7 @@ IMPLOT_API void EndSubplots();
|
|||
// call it for you.
|
||||
|
||||
// Enables an axis or sets the label and/or flags for an existing axis. Leave #label = NULL for no label.
|
||||
IMPLOT_API void SetupAxis(ImAxis axis, const char* label = NULL, ImPlotAxisFlags flags = ImPlotAxisFlags_None);
|
||||
IMPLOT_API void SetupAxis(ImAxis axis, const char* label=NULL, ImPlotAxisFlags flags=0);
|
||||
// Sets an axis range limits. If ImPlotCond_Always is used, the axes limits will be locked.
|
||||
IMPLOT_API void SetupAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond = ImPlotCond_Once);
|
||||
// Links an axis range limits to external values. Set to NULL for no linkage. The pointer data must remain valid until EndPlot.
|
||||
|
|
@ -588,21 +715,29 @@ IMPLOT_API void SetupAxisLinks(ImAxis axis, double* link_min, double* link_max);
|
|||
// Sets the format of numeric axis labels via formater specifier (default="%g"). Formated values will be double (i.e. use %f).
|
||||
IMPLOT_API void SetupAxisFormat(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.
|
||||
IMPLOT_API void SetupAxisFormat(ImAxis axis, ImPlotFormatter formatter, void* data = NULL);
|
||||
IMPLOT_API void SetupAxisFormat(ImAxis axis, ImPlotFormatter formatter, void* data=NULL);
|
||||
// Sets an axis' ticks and optionally the labels. To keep the default ticks, set #keep_default=true.
|
||||
IMPLOT_API void SetupAxisTicks(ImAxis axis, const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
|
||||
IMPLOT_API void SetupAxisTicks(ImAxis axis, const double* values, int n_ticks, const char* const labels[]=NULL, 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.
|
||||
IMPLOT_API void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
|
||||
IMPLOT_API void SetupAxisTicks(ImAxis axis, double v_min, double v_max, int n_ticks, const char* const labels[]=NULL, bool keep_default=false);
|
||||
// Sets an axis' scale using built-in options.
|
||||
IMPLOT_API void SetupAxisScale(ImAxis axis, ImPlotScale scale);
|
||||
// Sets an axis' scale using user supplied forward and inverse transfroms.
|
||||
IMPLOT_API void SetupAxisScale(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse, void* data=NULL);
|
||||
// Sets an axis' limits constraints.
|
||||
IMPLOT_API void SetupAxisLimitsConstraints(ImAxis axis, double v_min, double v_max);
|
||||
// Sets an axis' zoom constraints.
|
||||
IMPLOT_API void SetupAxisZoomConstraints(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).
|
||||
IMPLOT_API void SetupAxes(const char* x_label, const char* y_label, ImPlotAxisFlags x_flags = ImPlotAxisFlags_None, ImPlotAxisFlags y_flags = ImPlotAxisFlags_None);
|
||||
IMPLOT_API void SetupAxes(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).
|
||||
IMPLOT_API void SetupAxesLimits(double x_min, double x_max, double y_min, double y_max, ImPlotCond cond = ImPlotCond_Once);
|
||||
|
||||
// Sets up the plot legend.
|
||||
IMPLOT_API void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags = ImPlotLegendFlags_None);
|
||||
IMPLOT_API void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags=0);
|
||||
// Set the location of the current plot's mouse position text (default = South|East).
|
||||
IMPLOT_API void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags = ImPlotMouseTextFlags_None);
|
||||
IMPLOT_API void SetupMouseText(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.
|
||||
|
|
@ -666,7 +801,7 @@ IMPLOT_API void SetNextAxesToFit();
|
|||
// struct Vector2f { float X, Y; };
|
||||
// ...
|
||||
// Vector2f data[42];
|
||||
// ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, sizeof(Vector2f)); // or sizeof(float)*2
|
||||
// ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, 0, 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
|
||||
|
|
@ -680,7 +815,7 @@ IMPLOT_API void SetNextAxesToFit();
|
|||
// return p
|
||||
// }
|
||||
// ...
|
||||
// auto my_lambda = [](void*, int idx) {
|
||||
// auto my_lambda = [](int idx, void*) {
|
||||
// double t = idx / 999.0;
|
||||
// return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
|
||||
// };
|
||||
|
|
@ -696,86 +831,71 @@ IMPLOT_API void SetNextAxesToFit();
|
|||
// if you try plotting extremely large 64-bit integral types. Proceed with caution!
|
||||
|
||||
// Plots a standard 2D line plot.
|
||||
IMPLOT_TMP void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotLine(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
IMPLOT_TMP void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotLineFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotLine(const char* label_id, const T* xs, const T* ys, int count, ImPlotLineFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotLineFlags flags=0);
|
||||
|
||||
// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
||||
IMPLOT_TMP void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
IMPLOT_TMP void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotScatterFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, ImPlotScatterFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotScatterFlags flags=0);
|
||||
|
||||
// Plots a a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
|
||||
IMPLOT_TMP void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
// 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]
|
||||
IMPLOT_TMP void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, ImPlotStairsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotStairsFlags flags=0);
|
||||
|
||||
// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yref to +/-INFINITY for infinite fill extents.
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double yref=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count);
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double xstart=0, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double yref=0, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, ImPlotShadedFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count, ImPlotShadedFlags flags=0);
|
||||
|
||||
// Plots a vertical bar graph. #bar_width and #x0 are in X units.
|
||||
IMPLOT_TMP void PlotBars(const char* label_id, const T* values, int count, double bar_width=0.67, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double bar_width, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_width);
|
||||
// Plots a bar graph. Vertical by default. #bar_size and #shift are in plot units.
|
||||
IMPLOT_TMP void PlotBars(const char* label_id, const T* values, int count, double bar_size=0.67, double shift=0, ImPlotBarsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double bar_size, ImPlotBarsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_size, ImPlotBarsFlags flags=0);
|
||||
|
||||
// Plots a horizontal bar graph. #bar_height and #y0 are in Y units.
|
||||
IMPLOT_TMP void PlotBarsH(const char* label_id, const T* values, int count, double bar_height=0.67, double y0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double bar_height, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_height);
|
||||
|
||||
// Plots a group of vertical bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
|
||||
IMPLOT_TMP void PlotBarGroups(const char* const label_ids[], const T* values, int item_count, int group_count, double group_width=0.67, double x0=0, ImPlotBarGroupsFlags flags=ImPlotBarGroupsFlags_None);
|
||||
|
||||
// Plots a group of horizontal bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
|
||||
IMPLOT_TMP void PlotBarGroupsH(const char* const label_ids[], const T* values, int item_count, int group_count, double group_height=0.67, double y0=0, ImPlotBarGroupsFlags flags=ImPlotBarGroupsFlags_None);
|
||||
// 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.
|
||||
IMPLOT_TMP void PlotBarGroups(const char* const label_ids[], const T* values, int item_count, int group_count, double group_size=0.67, double shift=0, ImPlotBarGroupsFlags flags=0);
|
||||
|
||||
// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
||||
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, ImPlotErrorBarsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, ImPlotErrorBarsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
|
||||
// Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
|
||||
IMPLOT_TMP void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
|
||||
// Plots stems. Vertical by default.
|
||||
IMPLOT_TMP void PlotStems(const char* label_id, const T* values, int count, double ref=0, double scale=1, double start=0, ImPlotStemsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double ref=0, ImPlotStemsFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
|
||||
/// Plots vertical stems.
|
||||
IMPLOT_TMP void PlotStems(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double yref=0, int offset=0, int stride=sizeof(T));
|
||||
// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
||||
IMPLOT_TMP void PlotInfLines(const char* label_id, const T* values, int count, ImPlotInfLinesFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
|
||||
/// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
|
||||
IMPLOT_TMP void PlotVLines(const char* label_id, const T* xs, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_TMP void PlotHLines(const char* label_id, const T* ys, int count, int offset=0, int stride=sizeof(T));
|
||||
// Plots a pie chart. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
||||
IMPLOT_TMP void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, const char* label_fmt="%.1f", double angle0=90, ImPlotPieChartFlags flags=0);
|
||||
|
||||
// Plots a pie chart. If the sum of values > 1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
|
||||
IMPLOT_TMP void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize=false, const char* label_fmt="%.1f", double angle0=90);
|
||||
// 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 NULL for no labels.
|
||||
IMPLOT_TMP void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1), ImPlotHeatmapFlags flags=0);
|
||||
|
||||
// Plots a 2D heatmap chart. Values are expected to be in row-major order. 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 NULL for no labels.
|
||||
IMPLOT_TMP void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1));
|
||||
// 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.
|
||||
IMPLOT_TMP double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, double bar_scale=1.0, ImPlotRange range=ImPlotRange(), ImPlotHistogramFlags flags=0);
|
||||
|
||||
// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
|
||||
// If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
|
||||
// If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
|
||||
IMPLOT_TMP double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, bool cumulative=false, bool density=false, ImPlotRange range=ImPlotRange(), bool outliers=true, double bar_scale=1.0);
|
||||
|
||||
// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
|
||||
// If #bounds is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #bounds is specified, outlier values outside of range are not binned.
|
||||
// However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
|
||||
IMPLOT_TMP double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, bool density=false, ImPlotRect range=ImPlotRect(), bool outliers=true);
|
||||
// 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.
|
||||
IMPLOT_TMP double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, ImPlotRect range=ImPlotRect(), ImPlotHistogramFlags flags=0);
|
||||
|
||||
// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
||||
IMPLOT_TMP void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
IMPLOT_TMP void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, ImPlotDigitalFlags flags=0, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count, ImPlotDigitalFlags flags=0);
|
||||
|
||||
// Plots an axis-aligned image. #bounds_min/bounds_max are in plot coordinates (y-up) and #uv0/uv1 are in texture coordinates (y-down).
|
||||
IMPLOT_API void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, const ImVec2& uv0=ImVec2(0,0), const ImVec2& uv1=ImVec2(1,1), const ImVec4& tint_col=ImVec4(1,1,1,1));
|
||||
IMPLOT_API void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max, const ImVec2& uv0=ImVec2(0,0), const ImVec2& uv1=ImVec2(1,1), const ImVec4& tint_col=ImVec4(1,1,1,1), ImPlotImageFlags flags=0);
|
||||
|
||||
// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
|
||||
IMPLOT_API void PlotText(const char* text, double x, double y, bool vertical=false, const ImVec2& pix_offset=ImVec2(0,0));
|
||||
IMPLOT_API void PlotText(const char* text, double x, double y, const ImVec2& pix_offset=ImVec2(0,0), ImPlotTextFlags flags=0);
|
||||
|
||||
// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
|
||||
IMPLOT_API void PlotDummy(const char* label_id);
|
||||
IMPLOT_API void PlotDummy(const char* label_id, ImPlotDummyFlags flags=0);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Plot Tools
|
||||
|
|
@ -786,28 +906,28 @@ IMPLOT_API void PlotDummy(const char* label_id);
|
|||
// axes, which can be changed with `SetAxis/SetAxes`.
|
||||
|
||||
// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragPoint(int id, double* x, double* y, const ImVec4& col, float size = 4, ImPlotDragToolFlags flags = ImPlotDragToolFlags_None);
|
||||
IMPLOT_API bool DragPoint(int id, double* x, double* y, const ImVec4& col, float size = 4, ImPlotDragToolFlags flags=0);
|
||||
// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragLineX(int id, double* x, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags = ImPlotDragToolFlags_None);
|
||||
IMPLOT_API bool DragLineX(int id, double* x, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags=0);
|
||||
// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragLineY(int id, double* y, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags = ImPlotDragToolFlags_None);
|
||||
IMPLOT_API bool DragLineY(int id, double* y, const ImVec4& col, float thickness = 1, ImPlotDragToolFlags flags=0);
|
||||
// Shows a draggable and resizeable rectangle.
|
||||
IMPLOT_API bool DragRect(int id, double* x_min, double* y_min, double* x_max, double* y_max, const ImVec4& col, ImPlotDragToolFlags flags = ImPlotDragToolFlags_None);
|
||||
IMPLOT_API bool DragRect(int id, double* x_min, double* y_min, double* x_max, double* y_max, const ImVec4& col, ImPlotDragToolFlags flags=0);
|
||||
|
||||
// Shows an annotation callout at a chosen point. Clamping keeps annotations in the plot area. Annotations are always rendered on top.
|
||||
IMPLOT_API void Annotation(double x, double y, const ImVec4& color, const ImVec2& pix_offset, bool clamp, bool round = false);
|
||||
IMPLOT_API void Annotation(double x, double y, const ImVec4& color, const ImVec2& pix_offset, bool clamp, const char* fmt, ...) IM_FMTARGS(6);
|
||||
IMPLOT_API void AnnotationV(double x, double y, const ImVec4& color, const ImVec2& pix_offset, bool clamp, const char* fmt, va_list args) IM_FMTLIST(6);
|
||||
IMPLOT_API void Annotation(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, bool round = false);
|
||||
IMPLOT_API void Annotation(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, const char* fmt, ...) IM_FMTARGS(6);
|
||||
IMPLOT_API void AnnotationV(double x, double y, const ImVec4& col, const ImVec2& pix_offset, bool clamp, const char* fmt, va_list args) IM_FMTLIST(6);
|
||||
|
||||
// Shows a x-axis tag at the specified coordinate value.
|
||||
IMPLOT_API void TagX(double x, const ImVec4& color, bool round = false);
|
||||
IMPLOT_API void TagX(double x, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(3);
|
||||
IMPLOT_API void TagXV(double x, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(3);
|
||||
IMPLOT_API void TagX(double x, const ImVec4& col, bool round = false);
|
||||
IMPLOT_API void TagX(double x, const ImVec4& col, const char* fmt, ...) IM_FMTARGS(3);
|
||||
IMPLOT_API void TagXV(double x, const ImVec4& col, const char* fmt, va_list args) IM_FMTLIST(3);
|
||||
|
||||
// Shows a y-axis tag at the specified coordinate value.
|
||||
IMPLOT_API void TagY(double y, const ImVec4& color, bool round = false);
|
||||
IMPLOT_API void TagY(double y, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(3);
|
||||
IMPLOT_API void TagYV(double y, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(3);
|
||||
IMPLOT_API void TagY(double y, const ImVec4& col, bool round = false);
|
||||
IMPLOT_API void TagY(double y, const ImVec4& col, const char* fmt, ...) IM_FMTARGS(3);
|
||||
IMPLOT_API void TagYV(double y, const ImVec4& col, const char* fmt, va_list args) IM_FMTLIST(3);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Plot Utils
|
||||
|
|
@ -869,7 +989,7 @@ IMPLOT_API void EndAlignedPlots();
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Begin a popup for a legend entry.
|
||||
IMPLOT_API bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button = 1);
|
||||
IMPLOT_API bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_button=1);
|
||||
// End a popup for a legend entry.
|
||||
IMPLOT_API void EndLegendPopup();
|
||||
// Returns true if a plot item legend entry is hovered.
|
||||
|
|
@ -892,11 +1012,11 @@ IMPLOT_API void EndDragDropTarget();
|
|||
// You can change the modifier if desired. If ImGuiModFlags_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!
|
||||
IMPLOT_API bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags = 0);
|
||||
IMPLOT_API bool BeginDragDropSourcePlot(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!
|
||||
IMPLOT_API bool BeginDragDropSourceAxis(ImAxis axis, ImGuiDragDropFlags flags = 0);
|
||||
IMPLOT_API bool BeginDragDropSourceAxis(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!
|
||||
IMPLOT_API bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags = 0);
|
||||
IMPLOT_API bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags flags=0);
|
||||
// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
|
||||
IMPLOT_API void EndDragDropSource();
|
||||
|
||||
|
|
@ -1140,8 +1260,8 @@ IMPLOT_DEPRECATED( IMPLOT_API bool BeginPlot(const char* title_id,
|
|||
const char* y_label, // = NULL,
|
||||
const ImVec2& size = ImVec2(-1,0),
|
||||
ImPlotFlags flags = ImPlotFlags_None,
|
||||
ImPlotAxisFlags x_flags = ImPlotAxisFlags_None,
|
||||
ImPlotAxisFlags y_flags = ImPlotAxisFlags_None,
|
||||
ImPlotAxisFlags x_flags = 0,
|
||||
ImPlotAxisFlags y_flags = 0,
|
||||
ImPlotAxisFlags y2_flags = ImPlotAxisFlags_AuxDefault,
|
||||
ImPlotAxisFlags y3_flags = ImPlotAxisFlags_AuxDefault,
|
||||
const char* y2_label = NULL,
|
||||
|
|
|
|||
836
implot_demo.cpp
836
implot_demo.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -1,6 +1,6 @@
|
|||
// MIT License
|
||||
|
||||
// Copyright (c) 2021 Evan Pezent
|
||||
// Copyright (c) 2022 Evan Pezent
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
// ImPlot v0.13 WIP
|
||||
// ImPlot v0.14
|
||||
|
||||
// You may use this file to debug, understand or extend ImPlot features but we
|
||||
// don't provide any guarantee of forward compatibility!
|
||||
|
|
@ -63,8 +63,6 @@
|
|||
#define IMPLOT_LABEL_FORMAT "%g"
|
||||
// Max character size for tick labels
|
||||
#define IMPLOT_LABEL_MAX_SIZE 32
|
||||
// Plot values less than or equal to 0 will be replaced with this on log scale axes
|
||||
#define IMPLOT_LOG_ZERO DBL_MIN
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Macros
|
||||
|
|
@ -90,6 +88,7 @@ struct ImPlotItem;
|
|||
struct ImPlotLegend;
|
||||
struct ImPlotPlot;
|
||||
struct ImPlotNextPlotData;
|
||||
struct ImPlotTicker;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Context Pointer
|
||||
|
|
@ -106,6 +105,10 @@ extern IMPLOT_API ImPlotContext* GImPlot; // Current implicit context pointer
|
|||
// Computes the common (base-10) logarithm
|
||||
static inline float ImLog10(float x) { return log10f(x); }
|
||||
static inline double ImLog10(double x) { return log10(x); }
|
||||
static inline float ImSinh(float x) { return sinhf(x); }
|
||||
static inline double ImSinh(double x) { return sinh(x); }
|
||||
static inline float ImAsinh(float x) { return asinhf(x); }
|
||||
static inline double ImAsinh(double x) { return asinh(x); }
|
||||
// Returns true if a flag is set
|
||||
template <typename TSet, typename TFlag>
|
||||
static inline bool ImHasFlag(TSet set, TFlag flag) { return (set & flag) == flag; }
|
||||
|
|
@ -120,10 +123,12 @@ template <typename T>
|
|||
static inline T ImRemap01(T x, T x0, T x1) { return (x - x0) / (x1 - x0); }
|
||||
// Returns always positive modulo (assumes r != 0)
|
||||
static inline int ImPosMod(int l, int r) { return (l % r + r) % r; }
|
||||
// Returns true if val is NAN
|
||||
static inline bool ImNan(double val) { return isnan(val); }
|
||||
// Returns true if val is NAN or INFINITY
|
||||
static inline bool ImNanOrInf(double val) { return !(val >= -DBL_MAX && val <= DBL_MAX) || isnan(val); }
|
||||
static inline bool ImNanOrInf(double val) { return !(val >= -DBL_MAX && val <= DBL_MAX) || ImNan(val); }
|
||||
// Turns NANs to 0s
|
||||
static inline double ImConstrainNan(double val) { return isnan(val) ? 0 : val; }
|
||||
static inline double ImConstrainNan(double val) { return ImNan(val) ? 0 : val; }
|
||||
// Turns infinity to floating point maximums
|
||||
static inline double ImConstrainInf(double val) { return val >= DBL_MAX ? DBL_MAX : val <= -DBL_MAX ? - DBL_MAX : val; }
|
||||
// Turns numbers less than or equal to 0 to 0.001 (sort of arbitrary, is there a better way?)
|
||||
|
|
@ -215,23 +220,20 @@ static inline ImU32 ImAlphaU32(ImU32 col, float alpha) {
|
|||
return col & ~((ImU32)((1.0f-alpha)*255)<<IM_COL32_A_SHIFT);
|
||||
}
|
||||
|
||||
// Returns true of two ranges overlap
|
||||
template <typename T>
|
||||
static inline bool ImOverlaps(T min_a, T max_a, T min_b, T max_b) {
|
||||
return min_a <= max_b && min_b <= max_a;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] ImPlot Enums
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
typedef int ImPlotScale; // -> enum ImPlotScale_
|
||||
typedef int ImPlotTimeUnit; // -> enum ImPlotTimeUnit_
|
||||
typedef int ImPlotDateFmt; // -> enum ImPlotDateFmt_
|
||||
typedef int ImPlotTimeFmt; // -> enum ImPlotTimeFmt_
|
||||
|
||||
// XY axes scaling combinations
|
||||
enum ImPlotScale_ {
|
||||
ImPlotScale_LinLin, // linear x, linear y
|
||||
ImPlotScale_LogLin, // log x, linear y
|
||||
ImPlotScale_LinLog, // linear x, log y
|
||||
ImPlotScale_LogLog // log x, log y
|
||||
};
|
||||
|
||||
enum ImPlotTimeUnit_ {
|
||||
ImPlotTimeUnit_Us, // microsecond
|
||||
ImPlotTimeUnit_Ms, // millisecond
|
||||
|
|
@ -266,12 +268,19 @@ enum ImPlotTimeFmt_ { // default [ 24 Hour Clock ]
|
|||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] ImPlot Structs
|
||||
// [SECTION] Callbacks
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
typedef void (*ImPlotLocator)(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Structs
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Combined date/time format spec
|
||||
struct ImPlotDateTimeFmt {
|
||||
ImPlotDateTimeFmt(ImPlotDateFmt date_fmt, ImPlotTimeFmt time_fmt, bool use_24_hr_clk = false, bool use_iso_8601 = false) {
|
||||
struct ImPlotDateTimeSpec {
|
||||
ImPlotDateTimeSpec() {}
|
||||
ImPlotDateTimeSpec(ImPlotDateFmt date_fmt, ImPlotTimeFmt time_fmt, bool use_24_hr_clk = false, bool use_iso_8601 = false) {
|
||||
Date = date_fmt;
|
||||
Time = time_fmt;
|
||||
UseISO8601 = use_iso_8601;
|
||||
|
|
@ -409,7 +418,6 @@ struct ImPlotColormapData {
|
|||
int idx = Quals[cmap] ? ImClamp((int)(siz*t),0,siz-1) : (int)((siz - 1) * t + 0.5f);
|
||||
return Tables[off + idx];
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// ImPlotPoint with positive/negative error values
|
||||
|
|
@ -528,38 +536,41 @@ struct ImPlotTick
|
|||
bool Major;
|
||||
bool ShowLabel;
|
||||
int Level;
|
||||
int Idx;
|
||||
|
||||
ImPlotTick(double value, bool major, bool show_label) {
|
||||
ImPlotTick(double value, bool major, int level, bool show_label) {
|
||||
PlotPos = value;
|
||||
Major = major;
|
||||
ShowLabel = show_label;
|
||||
Level = level;
|
||||
TextOffset = -1;
|
||||
Level = 0;
|
||||
}
|
||||
};
|
||||
|
||||
// Collection of ticks
|
||||
struct ImPlotTickCollection {
|
||||
struct ImPlotTicker {
|
||||
ImVector<ImPlotTick> Ticks;
|
||||
ImGuiTextBuffer TextBuffer;
|
||||
ImVec2 MaxSize;
|
||||
ImVec2 LateSize;
|
||||
int Size;
|
||||
int Levels;
|
||||
|
||||
ImPlotTickCollection() { Reset(); }
|
||||
|
||||
const ImPlotTick& Append(const ImPlotTick& tick) {
|
||||
if (tick.ShowLabel) {
|
||||
MaxSize.x = tick.LabelSize.x > MaxSize.x ? tick.LabelSize.x : MaxSize.x;
|
||||
MaxSize.y = tick.LabelSize.y > MaxSize.y ? tick.LabelSize.y : MaxSize.y;
|
||||
}
|
||||
Ticks.push_back(tick);
|
||||
Size++;
|
||||
return Ticks.back();
|
||||
ImPlotTicker() {
|
||||
Reset();
|
||||
}
|
||||
|
||||
const ImPlotTick& Append(double value, bool major, bool show_label, ImPlotFormatter formatter, void* data) {
|
||||
ImPlotTick tick(value, major, show_label);
|
||||
ImPlotTick& AddTick(double value, bool major, int level, bool show_label, const char* label) {
|
||||
ImPlotTick tick(value, major, level, show_label);
|
||||
if (show_label && label != NULL) {
|
||||
tick.TextOffset = TextBuffer.size();
|
||||
TextBuffer.append(label, label + strlen(label) + 1);
|
||||
tick.LabelSize = ImGui::CalcTextSize(TextBuffer.Buf.Data + tick.TextOffset);
|
||||
}
|
||||
return AddTick(tick);
|
||||
}
|
||||
|
||||
ImPlotTick& AddTick(double value, bool major, int level, bool show_label, ImPlotFormatter formatter, void* data) {
|
||||
ImPlotTick tick(value, major, level, show_label);
|
||||
if (show_label && formatter != NULL) {
|
||||
char buff[IMPLOT_LABEL_MAX_SIZE];
|
||||
tick.TextOffset = TextBuffer.size();
|
||||
|
|
@ -567,16 +578,25 @@ struct ImPlotTickCollection {
|
|||
TextBuffer.append(buff, buff + strlen(buff) + 1);
|
||||
tick.LabelSize = ImGui::CalcTextSize(TextBuffer.Buf.Data + tick.TextOffset);
|
||||
}
|
||||
return Append(tick);
|
||||
return AddTick(tick);
|
||||
}
|
||||
|
||||
inline ImPlotTick& AddTick(ImPlotTick tick) {
|
||||
if (tick.ShowLabel) {
|
||||
MaxSize.x = tick.LabelSize.x > MaxSize.x ? tick.LabelSize.x : MaxSize.x;
|
||||
MaxSize.y = tick.LabelSize.y > MaxSize.y ? tick.LabelSize.y : MaxSize.y;
|
||||
}
|
||||
tick.Idx = Ticks.size();
|
||||
Ticks.push_back(tick);
|
||||
return Ticks.back();
|
||||
}
|
||||
|
||||
const char* GetText(int idx) const {
|
||||
return TextBuffer.Buf.Data + Ticks[idx].TextOffset;
|
||||
}
|
||||
|
||||
void OverrideSize(const ImVec2& size) {
|
||||
MaxSize.x = size.x > MaxSize.x ? size.x : MaxSize.x;
|
||||
MaxSize.y = size.y > MaxSize.y ? size.y : MaxSize.y;
|
||||
const char* GetText(const ImPlotTick& tick) {
|
||||
return GetText(tick.Idx);
|
||||
}
|
||||
|
||||
void OverrideSizeLate(const ImVec2& size) {
|
||||
|
|
@ -589,7 +609,11 @@ struct ImPlotTickCollection {
|
|||
TextBuffer.Buf.shrink(0);
|
||||
MaxSize = LateSize;
|
||||
LateSize = ImVec2(0,0);
|
||||
Size = 0;
|
||||
Levels = 1;
|
||||
}
|
||||
|
||||
int TickCount() const {
|
||||
return Ticks.Size;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -599,24 +623,38 @@ struct ImPlotAxis
|
|||
ImGuiID ID;
|
||||
ImPlotAxisFlags Flags;
|
||||
ImPlotAxisFlags PreviousFlags;
|
||||
ImPlotCond RangeCond;
|
||||
ImPlotTickCollection Ticks;
|
||||
ImPlotRange Range;
|
||||
ImPlotCond RangeCond;
|
||||
ImPlotScale Scale;
|
||||
ImPlotRange FitExtents;
|
||||
ImPlotAxis* OrthoAxis;
|
||||
ImPlotRange ConstraintRange;
|
||||
ImPlotRange ConstraintZoom;
|
||||
|
||||
ImPlotTicker Ticker;
|
||||
ImPlotFormatter Formatter;
|
||||
void* FormatterData;
|
||||
char FormatSpec[16];
|
||||
ImPlotLocator Locator;
|
||||
|
||||
double* LinkedMin;
|
||||
double* LinkedMax;
|
||||
|
||||
int PickerLevel;
|
||||
ImPlotTime PickerTimeMin, PickerTimeMax;
|
||||
float Datum1, Datum2;
|
||||
|
||||
ImPlotTransform TransformForward;
|
||||
ImPlotTransform TransformInverse;
|
||||
void* TransformData;
|
||||
float PixelMin, PixelMax;
|
||||
double LinM, LogD;
|
||||
double ScaleMin, ScaleMax;
|
||||
double ScaleToPixel;
|
||||
float Datum1, Datum2;
|
||||
|
||||
ImRect HoverRect;
|
||||
int LabelOffset;
|
||||
ImU32 ColorMaj, ColorMin, ColorTick, ColorTxt, ColorBg, ColorHov, ColorAct, ColorHiLi;
|
||||
char FormatSpec[16];
|
||||
ImPlotFormatter Formatter;
|
||||
void* FormatterData;
|
||||
|
||||
bool Enabled;
|
||||
bool Vertical;
|
||||
bool FitThisFrame;
|
||||
|
|
@ -630,9 +668,14 @@ struct ImPlotAxis
|
|||
Flags = PreviousFlags = ImPlotAxisFlags_None;
|
||||
Range.Min = 0;
|
||||
Range.Max = 1;
|
||||
Scale = ImPlotScale_Linear;
|
||||
TransformForward = TransformInverse = NULL;
|
||||
TransformData = NULL;
|
||||
FitExtents.Min = HUGE_VAL;
|
||||
FitExtents.Max = -HUGE_VAL;
|
||||
OrthoAxis = NULL;
|
||||
ConstraintRange = ImPlotRange(-INFINITY,INFINITY);
|
||||
ConstraintZoom = ImPlotRange(DBL_MIN,INFINITY);
|
||||
LinkedMin = LinkedMax = NULL;
|
||||
PickerLevel = 0;
|
||||
Datum1 = Datum2 = 0;
|
||||
|
|
@ -642,32 +685,42 @@ struct ImPlotAxis
|
|||
ColorHiLi = IM_COL32_BLACK_TRANS;
|
||||
Formatter = NULL;
|
||||
FormatterData = NULL;
|
||||
Locator = NULL;
|
||||
Enabled = Hovered = Held = FitThisFrame = HasRange = HasFormatSpec = false;
|
||||
ShowDefaultTicks = true;
|
||||
}
|
||||
|
||||
inline void Reset() {
|
||||
Enabled = false;
|
||||
Scale = ImPlotScale_Linear;
|
||||
TransformForward = TransformInverse = NULL;
|
||||
TransformData = NULL;
|
||||
LabelOffset = -1;
|
||||
HasFormatSpec = false;
|
||||
Formatter = NULL;
|
||||
FormatterData = NULL;
|
||||
Locator = NULL;
|
||||
ShowDefaultTicks = true;
|
||||
FitThisFrame = false;
|
||||
FitExtents.Min = HUGE_VAL;
|
||||
FitExtents.Max = -HUGE_VAL;
|
||||
OrthoAxis = NULL;
|
||||
Ticks.Reset();
|
||||
ConstraintRange = ImPlotRange(-INFINITY,INFINITY);
|
||||
ConstraintZoom = ImPlotRange(DBL_MIN,INFINITY);
|
||||
Ticker.Reset();
|
||||
}
|
||||
|
||||
inline bool SetMin(double _min, bool force=false) {
|
||||
if (!force && IsLockedMin())
|
||||
return false;
|
||||
_min = ImConstrainNan(ImConstrainInf(_min));
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_LogScale))
|
||||
_min = ImConstrainLog(_min);
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_Time))
|
||||
_min = ImConstrainTime(_min);
|
||||
if (_min < ConstraintRange.Min)
|
||||
_min = ConstraintRange.Min;
|
||||
double z = Range.Max - _min;
|
||||
if (z < ConstraintZoom.Min)
|
||||
_min = Range.Max - ConstraintZoom.Min;
|
||||
if (z > ConstraintZoom.Max)
|
||||
_min = Range.Max - ConstraintZoom.Max;
|
||||
if (_min >= Range.Max)
|
||||
return false;
|
||||
Range.Min = _min;
|
||||
|
|
@ -680,10 +733,13 @@ struct ImPlotAxis
|
|||
if (!force && IsLockedMax())
|
||||
return false;
|
||||
_max = ImConstrainNan(ImConstrainInf(_max));
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_LogScale))
|
||||
_max = ImConstrainLog(_max);
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_Time))
|
||||
_max = ImConstrainTime(_max);
|
||||
if (_max > ConstraintRange.Max)
|
||||
_max = ConstraintRange.Max;
|
||||
double z = _max - Range.Min;
|
||||
if (z < ConstraintZoom.Min)
|
||||
_max = Range.Min + ConstraintZoom.Min;
|
||||
if (z > ConstraintZoom.Max)
|
||||
_max = Range.Min + ConstraintZoom.Max;
|
||||
if (_max <= Range.Min)
|
||||
return false;
|
||||
Range.Max = _max;
|
||||
|
|
@ -725,43 +781,59 @@ struct ImPlotAxis
|
|||
inline void Constrain() {
|
||||
Range.Min = ImConstrainNan(ImConstrainInf(Range.Min));
|
||||
Range.Max = ImConstrainNan(ImConstrainInf(Range.Max));
|
||||
if (IsLog()) {
|
||||
Range.Min = ImConstrainLog(Range.Min);
|
||||
Range.Max = ImConstrainLog(Range.Max);
|
||||
if (Range.Min < ConstraintRange.Min)
|
||||
Range.Min = ConstraintRange.Min;
|
||||
if (Range.Max > ConstraintRange.Max)
|
||||
Range.Max = ConstraintRange.Max;
|
||||
double z = Range.Size();
|
||||
if (z < ConstraintZoom.Min) {
|
||||
double delta = (ConstraintZoom.Min - z) * 0.5;
|
||||
Range.Min -= delta;
|
||||
Range.Max += delta;
|
||||
}
|
||||
if (IsTime()) {
|
||||
Range.Min = ImConstrainTime(Range.Min);
|
||||
Range.Max = ImConstrainTime(Range.Max);
|
||||
if (z > ConstraintZoom.Max) {
|
||||
double delta = (z - ConstraintZoom.Max) * 0.5f;
|
||||
Range.Min += delta;
|
||||
Range.Max -= delta;
|
||||
}
|
||||
if (Range.Max <= Range.Min)
|
||||
Range.Max = Range.Min + DBL_EPSILON;
|
||||
}
|
||||
|
||||
inline void UpdateTransformCache() {
|
||||
LinM = (PixelMax - PixelMin) / Range.Size();
|
||||
LogD = IsLog() ? ImLog10(Range.Max / Range.Min) : 0;
|
||||
ScaleToPixel = (PixelMax - PixelMin) / Range.Size();
|
||||
if (TransformForward != NULL) {
|
||||
ScaleMin = TransformForward(Range.Min, TransformData);
|
||||
ScaleMax = TransformForward(Range.Max, TransformData);
|
||||
}
|
||||
else {
|
||||
ScaleMin = Range.Min;
|
||||
ScaleMax = Range.Max;
|
||||
}
|
||||
}
|
||||
|
||||
inline float PlotToPixels(double plt) const {
|
||||
if (TransformForward != NULL) {
|
||||
double s = TransformForward(plt, TransformData);
|
||||
double t = (s - ScaleMin) / (ScaleMax - ScaleMin);
|
||||
plt = Range.Min + Range.Size() * t;
|
||||
}
|
||||
return (float)(PixelMin + ScaleToPixel * (plt - Range.Min));
|
||||
}
|
||||
|
||||
|
||||
inline double PixelsToPlot(float pix) const {
|
||||
double plt = (pix - PixelMin) / LinM + Range.Min;
|
||||
if (IsLog()) {
|
||||
double plt = (pix - PixelMin) / ScaleToPixel + Range.Min;
|
||||
if (TransformInverse != NULL) {
|
||||
double t = (plt - Range.Min) / Range.Size();
|
||||
plt = ImPow(10, t * LogD) * Range.Min;
|
||||
double s = t * (ScaleMax - ScaleMin) + ScaleMin;
|
||||
plt = TransformInverse(s, TransformData);
|
||||
}
|
||||
return plt;
|
||||
}
|
||||
|
||||
inline float PlotToPixels(double plt) const {
|
||||
if (IsLog()) {
|
||||
plt = plt <= 0.0 ? IMPLOT_LOG_ZERO : plt;
|
||||
double t = ImLog10(plt / Range.Min) / LogD;
|
||||
plt = ImLerp(Range.Min, Range.Max, (float)t);
|
||||
}
|
||||
return (float)(PixelMin + LinM * (plt - Range.Min));
|
||||
}
|
||||
|
||||
inline void ExtendFit(double v) {
|
||||
if (!ImNanOrInf(v) && !(IsLog() && v <= 0)) {
|
||||
if (!ImNanOrInf(v) && v >= ConstraintRange.Min && v <= ConstraintRange.Max) {
|
||||
FitExtents.Min = v < FitExtents.Min ? v : FitExtents.Min;
|
||||
FitExtents.Max = v > FitExtents.Max ? v : FitExtents.Max;
|
||||
}
|
||||
|
|
@ -770,7 +842,7 @@ struct ImPlotAxis
|
|||
inline void ExtendFitWith(ImPlotAxis& alt, double v, double v_alt) {
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_RangeFit) && !alt.Range.Contains(v_alt))
|
||||
return;
|
||||
if (!ImNanOrInf(v) && !(IsLog() && v <= 0)) {
|
||||
if (!ImNanOrInf(v) && v >= ConstraintRange.Min && v <= ConstraintRange.Max) {
|
||||
FitExtents.Min = v < FitExtents.Min ? v : FitExtents.Min;
|
||||
FitExtents.Max = v > FitExtents.Max ? v : FitExtents.Max;
|
||||
}
|
||||
|
|
@ -802,17 +874,29 @@ struct ImPlotAxis
|
|||
inline bool IsForeground() const { return ImHasFlag(Flags, ImPlotAxisFlags_Foreground); }
|
||||
inline bool IsAutoFitting() const { return ImHasFlag(Flags, ImPlotAxisFlags_AutoFit); }
|
||||
inline bool CanInitFit() const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoInitialFit) && !HasRange && !LinkedMin && !LinkedMax; }
|
||||
inline bool IsRangeLocked() const { return HasRange && RangeCond == ImPlotCond_Always; }
|
||||
inline bool IsRangeLocked() const { return HasRange && RangeCond == ImPlotCond_Always; }
|
||||
inline bool IsLockedMin() const { return !Enabled || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMin); }
|
||||
inline bool IsLockedMax() const { return !Enabled || IsRangeLocked() || ImHasFlag(Flags, ImPlotAxisFlags_LockMax); }
|
||||
inline bool IsLocked() const { return IsLockedMin() && IsLockedMax(); }
|
||||
inline bool IsInputLockedMin() const { return IsLockedMin() || IsAutoFitting(); }
|
||||
inline bool IsInputLockedMax() const { return IsLockedMax() || IsAutoFitting(); }
|
||||
inline bool IsInputLocked() const { return IsLocked() || IsAutoFitting(); }
|
||||
inline bool IsTime() const { return ImHasFlag(Flags, ImPlotAxisFlags_Time); }
|
||||
inline bool IsLog() const { return ImHasFlag(Flags, ImPlotAxisFlags_LogScale); }
|
||||
inline bool HasMenus() const { return !ImHasFlag(Flags, ImPlotAxisFlags_NoMenus); }
|
||||
|
||||
inline bool IsPanLocked(bool increasing) {
|
||||
if (ImHasFlag(Flags, ImPlotAxisFlags_PanStretch)) {
|
||||
return IsInputLocked();
|
||||
}
|
||||
else {
|
||||
if (IsLockedMin() || IsLockedMax() || IsAutoFitting())
|
||||
return false;
|
||||
if (increasing)
|
||||
return Range.Max == ConstraintRange.Max;
|
||||
else
|
||||
return Range.Min == ConstraintRange.Min;
|
||||
}
|
||||
}
|
||||
|
||||
void PushLinks() {
|
||||
if (LinkedMin) { *LinkedMin = Range.Min; }
|
||||
if (LinkedMax) { *LinkedMax = Range.Max; }
|
||||
|
|
@ -1021,7 +1105,7 @@ struct ImPlotPlot
|
|||
inline const char* GetAxisLabel(const ImPlotAxis& axis) const { return TextBuffer.Buf.Data + axis.LabelOffset; }
|
||||
};
|
||||
|
||||
// Holds subplot data that must persist afer EndSubplot
|
||||
// Holds subplot data that must persist after EndSubplot
|
||||
struct ImPlotSubplot {
|
||||
ImGuiID ID;
|
||||
ImPlotSubplotFlags Flags;
|
||||
|
|
@ -1077,23 +1161,23 @@ struct ImPlotNextPlotData
|
|||
|
||||
// Temporary data storage for upcoming item
|
||||
struct ImPlotNextItemData {
|
||||
ImVec4 Colors[5]; // ImPlotCol_Line, ImPlotCol_Fill, ImPlotCol_MarkerOutline, ImPlotCol_MarkerFill, ImPlotCol_ErrorBar
|
||||
float LineWeight;
|
||||
ImPlotMarker Marker;
|
||||
float MarkerSize;
|
||||
float MarkerWeight;
|
||||
float FillAlpha;
|
||||
float ErrorBarSize;
|
||||
float ErrorBarWeight;
|
||||
float DigitalBitHeight;
|
||||
float DigitalBitGap;
|
||||
bool RenderLine;
|
||||
bool RenderFill;
|
||||
bool RenderMarkerLine;
|
||||
bool RenderMarkerFill;
|
||||
bool HasHidden;
|
||||
bool Hidden;
|
||||
ImPlotCond HiddenCond;
|
||||
ImVec4 Colors[5]; // ImPlotCol_Line, ImPlotCol_Fill, ImPlotCol_MarkerOutline, ImPlotCol_MarkerFill, ImPlotCol_ErrorBar
|
||||
float LineWeight;
|
||||
ImPlotMarker Marker;
|
||||
float MarkerSize;
|
||||
float MarkerWeight;
|
||||
float FillAlpha;
|
||||
float ErrorBarSize;
|
||||
float ErrorBarWeight;
|
||||
float DigitalBitHeight;
|
||||
float DigitalBitGap;
|
||||
bool RenderLine;
|
||||
bool RenderFill;
|
||||
bool RenderMarkerLine;
|
||||
bool RenderMarkerFill;
|
||||
bool HasHidden;
|
||||
bool Hidden;
|
||||
ImPlotCond HiddenCond;
|
||||
ImPlotNextItemData() { Reset(); }
|
||||
void Reset() {
|
||||
for (int i = 0; i < 5; ++i)
|
||||
|
|
@ -1116,7 +1200,7 @@ struct ImPlotContext {
|
|||
ImPlotItem* PreviousItem;
|
||||
|
||||
// Tick Marks and Labels
|
||||
ImPlotTickCollection CTicks;
|
||||
ImPlotTicker CTicker;
|
||||
|
||||
// Annotation and Tabs
|
||||
ImPlotAnnotationCollection Annotations;
|
||||
|
|
@ -1214,12 +1298,25 @@ IMPLOT_API void ShowSubplotsContextMenu(ImPlotSubplot& subplot);
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Begins a new item. Returns false if the item should not be plotted. Pushes PlotClipRect.
|
||||
IMPLOT_API bool BeginItem(const char* label_id, ImPlotCol recolor_from = -1);
|
||||
IMPLOT_API bool BeginItem(const char* label_id, ImPlotItemFlags flags=0, ImPlotCol recolor_from=IMPLOT_AUTO);
|
||||
|
||||
// Same as above but with fitting functionality.
|
||||
template <typename _Fitter>
|
||||
bool BeginItemEx(const char* label_id, const _Fitter& fitter, ImPlotItemFlags flags=0, ImPlotCol recolor_from=IMPLOT_AUTO) {
|
||||
if (BeginItem(label_id, flags, recolor_from)) {
|
||||
ImPlotPlot& plot = *GetCurrentPlot();
|
||||
if (plot.FitThisFrame && !ImHasFlag(flags, ImPlotItemFlags_NoFit))
|
||||
fitter.Fit(plot.Axes[plot.CurrentX], plot.Axes[plot.CurrentY]);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Ends an item (call only if BeginItem returns true). Pops PlotClipRect.
|
||||
IMPLOT_API void EndItem();
|
||||
|
||||
// Register or get an existing item from the current plot.
|
||||
IMPLOT_API ImPlotItem* RegisterOrGetItem(const char* label_id, bool* just_created = NULL);
|
||||
IMPLOT_API ImPlotItem* RegisterOrGetItem(const char* label_id, ImPlotItemFlags flags, bool* just_created = NULL);
|
||||
// Get a plot item from the current plot.
|
||||
IMPLOT_API ImPlotItem* GetItem(const char* label_id);
|
||||
// Gets the current item.
|
||||
|
|
@ -1265,21 +1362,6 @@ static inline bool AnyAxesHovered(ImPlotAxis* axes, int count) {
|
|||
return false;
|
||||
}
|
||||
|
||||
// Gets the XY scale for the current plot and y-axis (TODO)
|
||||
static inline ImPlotScale GetCurrentScale() {
|
||||
ImPlotPlot& plot = *GetCurrentPlot();
|
||||
ImPlotAxis& x = plot.Axes[plot.CurrentX];
|
||||
ImPlotAxis& y = plot.Axes[plot.CurrentY];
|
||||
if (!x.IsLog() && !y.IsLog())
|
||||
return ImPlotScale_LinLin;
|
||||
else if (x.IsLog() && !y.IsLog())
|
||||
return ImPlotScale_LogLin;
|
||||
else if (!x.IsLog() && y.IsLog())
|
||||
return ImPlotScale_LinLog;
|
||||
else
|
||||
return ImPlotScale_LogLog;
|
||||
}
|
||||
|
||||
// Returns true if the user has requested data to be fit.
|
||||
static inline bool FitThisFrame() {
|
||||
return GImPlot->CurrentPlot->FitThisFrame;
|
||||
|
|
@ -1331,21 +1413,9 @@ IMPLOT_API void ShowAltLegend(const char* title_id, bool vertical = true, const
|
|||
IMPLOT_API bool ShowLegendContextMenu(ImPlotLegend& legend, bool visible);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Tick Utils
|
||||
// [SECTION] Label Utils
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Label a tick with time formatting.
|
||||
IMPLOT_API void LabelTickTime(ImPlotTick& tick, ImGuiTextBuffer& buffer, const ImPlotTime& t, ImPlotDateTimeFmt fmt);
|
||||
|
||||
// Populates a list of ImPlotTicks with normal spaced and formatted ticks
|
||||
IMPLOT_API void AddTicksDefault(const ImPlotRange& range, float pix, bool vertical, ImPlotTickCollection& ticks, ImPlotFormatter formatter, void* data);
|
||||
// Populates a list of ImPlotTicks with logarithmic space and formatted ticks
|
||||
IMPLOT_API void AddTicksLogarithmic(const ImPlotRange& range, float pix, bool vertical, ImPlotTickCollection& ticks, ImPlotFormatter formatter, void* data);
|
||||
// Populates a list of ImPlotTicks with custom spaced and labeled ticks
|
||||
IMPLOT_API void AddTicksCustom(const double* values, const char* const labels[], int n, ImPlotTickCollection& ticks, ImPlotFormatter formatter, void* data);
|
||||
// Populates a list of ImPlotTicks with time formatted ticks.
|
||||
IMPLOT_API void AddTicksTime(const ImPlotRange& range, float plot_width, ImPlotTickCollection& ticks);
|
||||
|
||||
// Create a a string label for a an axis value
|
||||
IMPLOT_API void LabelAxisValue(const ImPlotAxis& axis, double value, char* buff, int size, bool round = false);
|
||||
|
||||
|
|
@ -1503,7 +1573,7 @@ IMPLOT_API int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTim
|
|||
// Formats the date part of timestamp t into a buffer according to #fmt
|
||||
IMPLOT_API int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDateFmt fmt, bool use_iso_8601);
|
||||
// Formats the time and/or date parts of a timestamp t into a buffer according to #fmt
|
||||
IMPLOT_API int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeFmt fmt);
|
||||
IMPLOT_API int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlotDateTimeSpec fmt);
|
||||
|
||||
// Shows a date picker widget block (year/month/day).
|
||||
// #level = 0 for day, 1 for month, 2 for year. Modified by user interaction.
|
||||
|
|
@ -1514,4 +1584,73 @@ IMPLOT_API bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const
|
|||
// #t will be set when a new hour, minute, or sec is selected or am/pm is toggled, and the function will return true.
|
||||
IMPLOT_API bool ShowTimePicker(const char* id, ImPlotTime* t);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Transforms
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static inline double TransformForward_Log10(double v, void*) {
|
||||
v = v <= 0.0 ? DBL_MIN : v;
|
||||
return ImLog10(v);
|
||||
}
|
||||
|
||||
static inline double TransformInverse_Log10(double v, void*) {
|
||||
return ImPow(10, v);
|
||||
}
|
||||
|
||||
static inline double TransformForward_SymLog(double v, void*) {
|
||||
return 2.0 * ImAsinh(v / 2.0);
|
||||
}
|
||||
|
||||
static inline double TransformInverse_SymLog(double v, void*) {
|
||||
return 2.0 * ImSinh(v / 2.0);
|
||||
}
|
||||
|
||||
static inline double TransformForward_Logit(double v, void*) {
|
||||
v = ImClamp(v, DBL_MIN, 1.0 - DBL_EPSILON);
|
||||
return ImLog10(v / (1 - v));
|
||||
}
|
||||
|
||||
static inline double TransformInverse_Logit(double v, void*) {
|
||||
return 1.0 / (1.0 + ImPow(10,-v));
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Formatters
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static inline int Formatter_Default(double value, char* buff, int size, void* data) {
|
||||
char* fmt = (char*)data;
|
||||
return ImFormatString(buff, size, fmt, value);
|
||||
}
|
||||
|
||||
static inline int Formatter_Logit(double value, char* buff, int size, void*) {
|
||||
if (value == 0.5)
|
||||
return ImFormatString(buff,size,"1/2");
|
||||
else if (value < 0.5)
|
||||
return ImFormatString(buff,size,"%g", value);
|
||||
else
|
||||
return ImFormatString(buff,size,"1 - %g", 1 - value);
|
||||
}
|
||||
|
||||
struct Formatter_Time_Data {
|
||||
ImPlotTime Time;
|
||||
ImPlotDateTimeSpec Spec;
|
||||
ImPlotFormatter UserFormatter;
|
||||
void* UserFormatterData;
|
||||
};
|
||||
|
||||
static inline int Formatter_Time(double, char* buff, int size, void* data) {
|
||||
Formatter_Time_Data* ftd = (Formatter_Time_Data*)data;
|
||||
return FormatDateTime(ftd->Time, buff, size, ftd->Spec);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// [SECTION] Locator
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
void Locator_Default(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
|
||||
void Locator_Time(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
|
||||
void Locator_Log10(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
|
||||
void Locator_SymLog(ImPlotTicker& ticker, const ImPlotRange& range, float pixels, bool vertical, ImPlotFormatter formatter, void* formatter_data);
|
||||
|
||||
} // namespace ImPlot
|
||||
|
|
|
|||
2974
implot_items.cpp
2974
implot_items.cpp
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user