mirror of
https://github.com/gwm17/implot.git
synced 2024-11-22 18:28:53 -05:00
Setup API (#294)
* add new padding algo * opposite working for y and x * remove name axis colors * move title label rendering * axis dev * clean up * pre formatter * formatter * changing over to multi x axes * more multi x changes * more multi x changes * more multi x changes * setup 75% there * 85% there * 85% there * remove query * update input handling * input and dnd tweaking * input testing * update demo * setup debug * setup debug * bug fixes * bug fixes * more debug * input * more setup * setup api almost complete * setup api almost complete * more clean up * cleanup * final commit before merge
This commit is contained in:
Evan Pezent
GitHub
parent
dea3387cdc
commit
6ee1559715
16
README.md
16
README.md
|
|
@ -33,7 +33,7 @@ ImPlot is an immediate mode, GPU accelerated plotting library for [Dear ImGui](h
|
|||
- subplots
|
||||
- time formatted x-axes (US formatted or ISO 8601)
|
||||
- reversible and lockable axes
|
||||
- up to three independent y-axes
|
||||
- multiple x-axes and y-axes
|
||||
- controls for zooming, panning, box selection, and auto-fitting data
|
||||
- controls for creating persistent query ranges (see demo)
|
||||
- several plot styling options: 10 marker types, adjustable marker sizes, line weights, outline colors, fill colors, etc.
|
||||
|
|
@ -110,20 +110,20 @@ A: ImGui is an incredibly powerful tool for rapid prototyping and development, b
|
|||
|
||||
**Q: Is ImPlot the right plotting library for me?**
|
||||
|
||||
A: If you're looking to generate publication quality plots and/or export plots to a file, ImPlot is NOT the library for you. ImPlot is geared toward plotting application data at realtime speeds. ImPlot does its best to create pretty plots (indeed, there are quite a few styling options available), but it will always favor function over form.
|
||||
A: If you're looking to generate publication quality plots and/or export plots to a file, ImPlot is NOT the library for you! ImPlot is geared toward plotting application data at realtime speeds with high levels of interactivity. ImPlot does its best to create pretty plots (indeed, there are quite a few styling options available), but it will always favor function over form.
|
||||
|
||||
**Q: Where is the documentation?**
|
||||
|
||||
A: The API is thoroughly commented in `implot.h`, and the demo in `implot_demo.cpp` should be more than enough to get you started.
|
||||
A: The API is thoroughly commented in `implot.h`, and the demo in `implot_demo.cpp` should be more than enough to get you started. Also take a look at the [implot_demos](https://github.com/epezent/implot_demos) repository.
|
||||
|
||||
**Q: Is ImPlot suitable for plotting large datasets?**
|
||||
|
||||
A: Yes, within reason. You can plot tens to hundreds of thousands of points without issue, but don't expect millions to be a buttery smooth experience. That said, you can always downsample extremely large datasets by telling ImPlot to stride your data at larger intervals if needed.
|
||||
A: Yes, within reason. You can plot tens to hundreds of thousands of points without issue, but don't expect millions to be a buttery smooth experience. That said, you can always downsample extremely large datasets by telling ImPlot to stride your data at larger intervals if needed. Also try the experimental `backends` branch which aims to provide GPU acceleration support.
|
||||
|
||||
**Q: What data types can I plot?**
|
||||
|
||||
A: ImPlot plotting functions accept most scalar types:
|
||||
`float`, `double`, `int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`. Arrays of custom structs or classes (e.g. `Vector2f` or similar) are easily passed to ImPlot functions using the built in striding features (see `implot.h` for documentation).
|
||||
`float`, `double`, `int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`. Arrays of custom structs or classes (e.g. `Vector2f` or similar) are easily passed to ImPlot functions using the built in striding features (see `implot.h` for documentation), and many plotters provide a "getter" overload which accepts data generating callbacks.
|
||||
|
||||
**Q: Can plot styles be modified?**
|
||||
|
||||
|
|
@ -135,7 +135,7 @@ A: Yep! Both logscale and timescale are supported.
|
|||
|
||||
**Q: Does ImPlot support multiple y-axes? x-axes?**
|
||||
|
||||
A: Yes. Up to three y-axes can be enabled. Multiple x-axes are not supported.
|
||||
A: Yes. Up to three x-axes and three y-axes can be enabled.
|
||||
|
||||
**Q: Does ImPlot support [insert plot type]?**
|
||||
|
||||
|
|
@ -157,9 +157,9 @@ A: Not exactly, but it does give you the ability to query plot sub-ranges, with
|
|||
|
||||
A: Not currently. Use your OS's screen capturing mechanisms if you need to capture a plot. ImPlot is not suitable for rendering publication quality plots; it is only intended to be used as a visualization tool. Post-process your data with MATLAB or matplotlib for these purposes.
|
||||
|
||||
**Q: Can a compile ImPlot as a dynamic library?**
|
||||
**Q: Can I compile ImPlot as a dynamic library?**
|
||||
|
||||
A: Like ImGui, it is recommended that you compile and link ImPlot as a *static* library or directly as a part of your sources. However, if you are compiling ImPlot and ImGui as separate DLLs, make sure you set the current *ImGui* context with `ImPlot::SetImGuiContext(ImGuiContext* ctx)`. This ensures that global ImGui variables are correctly shared across the DLL boundary.
|
||||
A: Like ImGui, it is recommended that you compile and link ImPlot as a *static* library or directly as a part of your sources. However, if you must and are compiling ImPlot and ImGui as separate DLLs, make sure you set the current *ImGui* context with `ImPlot::SetImGuiContext(ImGuiContext* ctx)`. This ensures that global ImGui variables are correctly shared across the DLL boundary.
|
||||
|
||||
**Q: Can ImPlot be used with other languages/bindings?**
|
||||
|
||||
|
|
|
|||
51
TODO.md
51
TODO.md
|
|
@ -1,46 +1,69 @@
|
|||
The list below represents a combination of high-priority work, nice-to-have features, and random ideas. We make no guarantees that all of this work will be completed or even started. If you see something that you need or would like to have, let us know, or better yet consider submitting a PR for the feature.
|
||||
|
||||
## Plots
|
||||
## API
|
||||
|
||||
- remove axis-related args from signature of `BeginPlot` and add `SetupNextAxis` API
|
||||
- add a few overloads of `BeginPlot` that bypass `SetupNextAxis` for common scenarios
|
||||
- make current `BeginPlot` a wrapper to this API
|
||||
- add shortcut/legacy overloads for BeginPlot
|
||||
|
||||
## Axes
|
||||
|
||||
- add support for multiple x-axes and don't limit count to 3
|
||||
- will require `SetupNextAxis` API
|
||||
- make axis side configurable (top/left, right/bottom) via new flag `ImPlotAxisFlags_Opposite`
|
||||
- add support for setting tick label strings via callback
|
||||
- add flag to remove weekends on Time axis
|
||||
- pixel space scale (`ImPlotTransform_Display`), normalized space scale (`ImPlotTransform_Axes`), data space scale (`ImPloTransform_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
|
||||
- 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?)
|
||||
|
||||
## Styling
|
||||
|
||||
- support gradient and/or colormap sampled fills (e.g. ImPlotFillStyle_)
|
||||
- add hover/active color for plot
|
||||
- add hover/active color for plot axes
|
||||
- API for setting different fonts for plot elements
|
||||
|
||||
## Colormaps
|
||||
|
||||
- gradient editing tool
|
||||
- `RemoveColormap`
|
||||
|
||||
## Legend
|
||||
|
||||
- change `SetLegendLocation` API to be more consistent, i.e. `SetNextLegendLocation`
|
||||
- add legend scroll
|
||||
- `ImPlotLegendFlags_SortItems`
|
||||
- `ImPlotLegendFlags_Scroll`
|
||||
- improve legend icons (e.g. adopt markers, gradients, etc)
|
||||
- `ImPlotLegendFlags`
|
||||
- make legend frame use ButtonBehavior (maybe impossible)
|
||||
|
||||
## Tools / Misc.
|
||||
|
||||
- add `IsPlotChanging` to detect change in limits
|
||||
- add ability to extend plot/axis context menus
|
||||
- add LTTB downsampling for lines
|
||||
- add box selection to axes
|
||||
- first frame render delay might fix "fit pop" effect
|
||||
- move some code to new `implot_tools.cpp`
|
||||
|
||||
## Optimizations
|
||||
|
||||
- find faster way to buffer data into ImDrawList (very slow)
|
||||
- reduce number of calls to `PushClipRect`
|
||||
- explore SIMD operations for high density plot items
|
||||
|
||||
## Completed
|
||||
- make BeginPlot take fewer args:
|
||||
- make query a tool -> `DragRect`
|
||||
- rework DragLine/Point to use ButtonBehavior
|
||||
- add support for multiple x-axes and don't limit count to 3
|
||||
- make axis side configurable (top/left, right/bottom) via new flag `ImPlotAxisFlags_Opposite`
|
||||
- add support for setting tick label strings via callback
|
||||
- give each axis an ID, remove ad-hoc DND solution
|
||||
- allow axis to be drag to opposite side (ala ImGui Table headers)
|
||||
- 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
|
||||
|
|
|
|||
3791
implot.cpp
3791
implot.cpp
File diff suppressed because it is too large
Load Diff
615
implot.h
615
implot.h
|
|
@ -20,13 +20,35 @@
|
|||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
// ImPlot v0.12 WIP
|
||||
// ImPlot v0.13 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
|
||||
#include "imgui.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Macros and Defines
|
||||
// [SECTION] Macros and Defines
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
|
||||
|
|
@ -37,70 +59,87 @@
|
|||
#define IMPLOT_API
|
||||
#endif
|
||||
|
||||
// ImPlot version string
|
||||
#define IMPLOT_VERSION "0.12 WIP"
|
||||
// ImPlot version string.
|
||||
#define IMPLOT_VERSION "0.13 WIP"
|
||||
// Indicates variable should deduced automatically.
|
||||
#define IMPLOT_AUTO -1
|
||||
// Special color used to indicate that a color should be deduced automatically.
|
||||
#define IMPLOT_AUTO_COL ImVec4(0,0,0,-1)
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Forward Declarations and Basic Types
|
||||
// [SECTION] Enums and Types
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Forward declarations
|
||||
struct ImPlotContext; // ImPlot context (opaque struct, see implot_internal.h)
|
||||
|
||||
// Enums/Flags
|
||||
typedef int ImAxis; // -> enum ImAxis_
|
||||
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 ImPlotCond; // -> enum ImPlotCond_
|
||||
typedef int ImPlotCol; // -> enum ImPlotCol_
|
||||
typedef int ImPlotStyleVar; // -> enum ImPlotStyleVar_
|
||||
typedef int ImPlotMarker; // -> enum ImPlotMarker_
|
||||
typedef int ImPlotColormap; // -> enum ImPlotColormap_
|
||||
typedef int ImPlotLocation; // -> enum ImPlotLocation_
|
||||
typedef int ImPlotOrientation; // -> enum ImPlotOrientation_
|
||||
typedef int ImPlotYAxis; // -> enum ImPlotYAxis_;
|
||||
typedef int ImPlotBin; // -> enum ImPlotBin_
|
||||
|
||||
// Axis indices. The values assigned may change; NEVER hardcode these.
|
||||
enum ImAxis_ {
|
||||
// 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
|
||||
// bookeeping
|
||||
ImAxis_COUNT
|
||||
};
|
||||
|
||||
// Options for plots (see BeginPlot).
|
||||
enum ImPlotFlags_ {
|
||||
ImPlotFlags_None = 0, // default
|
||||
ImPlotFlags_NoTitle = 1 << 0, // the plot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MyPlot")
|
||||
ImPlotFlags_NoLegend = 1 << 1, // the legend will not be displayed
|
||||
ImPlotFlags_NoMenus = 1 << 2, // the user will not be able to open context menus with right-click
|
||||
ImPlotFlags_NoBoxSelect = 1 << 3, // the user will not be able to box-select with right-click drag
|
||||
ImPlotFlags_NoMousePos = 1 << 4, // the mouse position, in plot coordinates, will not be displayed inside of the plot
|
||||
ImPlotFlags_NoHighlight = 1 << 5, // plot items will not be highlighted when their legend entry is hovered
|
||||
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_NoChild = 1 << 6, // a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications)
|
||||
ImPlotFlags_Equal = 1 << 7, // primary x and y axes will be constrained to have the same units/pixel (does not apply to auxiliary y-axes)
|
||||
ImPlotFlags_YAxis2 = 1 << 8, // enable a 2nd y-axis on the right side
|
||||
ImPlotFlags_YAxis3 = 1 << 9, // enable a 3rd y-axis on the right side
|
||||
ImPlotFlags_Query = 1 << 10, // the user will be able to draw query rects with middle-mouse or CTRL + right-click drag
|
||||
ImPlotFlags_Crosshairs = 1 << 11, // the default mouse cursor will be replaced with a crosshair when hovered
|
||||
ImPlotFlags_AntiAliased = 1 << 12, // plot lines will be software anti-aliased (not recommended for high density plots, prefer MSAA)
|
||||
ImPlotFlags_CanvasOnly = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMousePos
|
||||
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_AntiAliased = 1 << 9, // 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
|
||||
};
|
||||
|
||||
// Options for plot axes (see BeginPlot).
|
||||
// Options for plot axes (see SetupAxis).
|
||||
enum ImPlotAxisFlags_ {
|
||||
ImPlotAxisFlags_None = 0, // default
|
||||
ImPlotAxisFlags_NoLabel = 1 << 0, // the axis label will not be displayed (axis labels also hidden if the supplied string name is NULL)
|
||||
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_Foreground = 1 << 4, // grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background
|
||||
ImPlotAxisFlags_LogScale = 1 << 5, // a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time)
|
||||
ImPlotAxisFlags_Time = 1 << 6, // axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale)
|
||||
ImPlotAxisFlags_Invert = 1 << 7, // the axis will be inverted
|
||||
ImPlotAxisFlags_NoInitialFit = 1 << 8, // axis will not be initially fit to data extents on the first rendered frame (also the case if SetNextPlotLimits explicitly called)
|
||||
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 **orthoganol** axis
|
||||
ImPlotAxisFlags_LockMin = 1 << 11, // the axis minimum value will be locked when panning/zooming
|
||||
ImPlotAxisFlags_LockMax = 1 << 12, // the axis maximum value will be locked when panning/zooming
|
||||
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_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_Lock = ImPlotAxisFlags_LockMin | ImPlotAxisFlags_LockMax,
|
||||
ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels
|
||||
ImPlotAxisFlags_NoDecorations = ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_NoTickMarks | ImPlotAxisFlags_NoTickLabels,
|
||||
ImPlotAxisFlags_AuxDefault = ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite
|
||||
};
|
||||
|
||||
// Options for subplots (see BeginSubplot).
|
||||
|
|
@ -112,13 +151,49 @@ enum ImPlotSubplotFlags_ {
|
|||
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 auxiliary y-axes)
|
||||
ImPlotSubplotFlags_LinkCols = 1 << 7, // link the x-axis limits of all plots in each column
|
||||
ImPlotSubplotFlags_LinkAllX = 1 << 8, // link the x-axis limits in every plot in the subplot
|
||||
ImPlotSubplotFlags_LinkAllY = 1 << 9 , // link the y-axis limits in every plot in the subplot (does not apply to auxiliary y-axes)
|
||||
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
|
||||
};
|
||||
|
||||
// Options for legends (see SetupLegend)
|
||||
enum ImPlotLegendFlags_ {
|
||||
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
|
||||
};
|
||||
|
||||
// Options for mouse hover text (see SetupMouseText)
|
||||
enum ImPlotMouseTextFlags_ {
|
||||
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
|
||||
};
|
||||
|
||||
// Options for DragPoint, DragLine, DragRect
|
||||
enum ImPlotDragToolFlags_ {
|
||||
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
|
||||
};
|
||||
|
||||
// Represents a condition for SetupAxisLimits etc. (same as ImGuiCond, but we only support a subset of those enums)
|
||||
enum ImPlotCond_
|
||||
{
|
||||
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)
|
||||
};
|
||||
|
||||
// Plot styling colors.
|
||||
enum ImPlotCol_ {
|
||||
// item styling colors
|
||||
|
|
@ -136,16 +211,12 @@ enum ImPlotCol_ {
|
|||
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_XAxis, // x-axis label and tick lables color (defaults to ImGuiCol_Text)
|
||||
ImPlotCol_XAxisGrid, // x-axis grid color (defaults to 25% ImPlotCol_XAxis)
|
||||
ImPlotCol_YAxis, // y-axis label and tick labels color (defaults to ImGuiCol_Text)
|
||||
ImPlotCol_YAxisGrid, // y-axis grid color (defaults to 25% ImPlotCol_YAxis)
|
||||
ImPlotCol_YAxis2, // 2nd y-axis label and tick labels color (defaults to ImGuiCol_Text)
|
||||
ImPlotCol_YAxisGrid2, // 2nd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis2)
|
||||
ImPlotCol_YAxis3, // 3rd y-axis label and tick labels color (defaults to ImGuiCol_Text)
|
||||
ImPlotCol_YAxisGrid3, // 3rd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis3)
|
||||
ImPlotCol_AxisText, // axis label and tick lables color (defaults to ImGuiCol_Text)
|
||||
ImPlotCol_AxisGrid, // axis grid and tick color (defaults to 25% ImPlotCol_XAxis)
|
||||
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_Query, // box-query color (defaults to green)
|
||||
ImPlotCol_Crosshairs, // crosshairs color (defaults to ImPlotCol_PlotBorder)
|
||||
ImPlotCol_COUNT
|
||||
};
|
||||
|
|
@ -233,19 +304,6 @@ enum ImPlotLocation_ {
|
|||
ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East // bottom-right
|
||||
};
|
||||
|
||||
// Used to orient items on a plot (e.g. legends, labels, etc.)
|
||||
enum ImPlotOrientation_ {
|
||||
ImPlotOrientation_Horizontal, // left/right
|
||||
ImPlotOrientation_Vertical // up/down
|
||||
};
|
||||
|
||||
// Enums for different y-axes.
|
||||
enum ImPlotYAxis_ {
|
||||
ImPlotYAxis_1 = 0, // left (default)
|
||||
ImPlotYAxis_2 = 1, // first on right side
|
||||
ImPlotYAxis_3 = 2 // second on right side
|
||||
};
|
||||
|
||||
// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
|
||||
enum ImPlotBin_ {
|
||||
ImPlotBin_Sqrt = -1, // k = sqrt(n)
|
||||
|
|
@ -268,22 +326,26 @@ struct ImPlotPoint {
|
|||
#endif
|
||||
};
|
||||
|
||||
// A range defined by a min/max value. Used for plot axes ranges.
|
||||
// Range defined by a min/max value.
|
||||
struct ImPlotRange {
|
||||
double Min, Max;
|
||||
ImPlotRange() { Min = 0; Max = 0; }
|
||||
ImPlotRange(double _min, double _max) { Min = _min; Max = _max; }
|
||||
bool Contains(double value) const { return value >= Min && value <= Max; };
|
||||
double Size() const { return Max - Min; };
|
||||
bool Contains(double value) const { return value >= Min && value <= Max; }
|
||||
double Size() const { return Max - Min; }
|
||||
double Clamp(double value) const { return (value < Min) ? Min : (value > Max) ? Max : value; }
|
||||
};
|
||||
|
||||
// Combination of two ranges for X and Y axes.
|
||||
struct ImPlotLimits {
|
||||
// Combination of two range limits for X and Y axes. Also an AABB defined by Min()/Max().
|
||||
struct ImPlotRect {
|
||||
ImPlotRange X, Y;
|
||||
ImPlotLimits() { }
|
||||
ImPlotLimits(double x_min, double x_max, double y_min, double y_max) { X.Min = x_min; X.Max = x_max; Y.Min = y_min; Y.Max = y_max; }
|
||||
ImPlotRect() { }
|
||||
ImPlotRect(double x_min, double x_max, double y_min, double y_max) { X.Min = x_min; X.Max = x_max; Y.Min = y_min; Y.Max = y_max; }
|
||||
bool Contains(const ImPlotPoint& p) const { return Contains(p.x, p.y); }
|
||||
bool Contains(double x, double y) const { return X.Contains(x) && Y.Contains(y); }
|
||||
ImPlotPoint Size() const { return ImPlotPoint(X.Size(), Y.Size()); }
|
||||
ImPlotPoint Clamp(const ImPlotPoint& p) { return Clamp(p.x, p.y); }
|
||||
ImPlotPoint Clamp(double x, double y) { return ImPlotPoint(X.Clamp(x),Y.Clamp(y)); }
|
||||
ImPlotPoint Min() const { return ImPlotPoint(X.Min, Y.Min); }
|
||||
ImPlotPoint Max() const { return ImPlotPoint(X.Max, Y.Max); }
|
||||
};
|
||||
|
|
@ -331,14 +393,37 @@ struct ImPlotStyle {
|
|||
IMPLOT_API ImPlotStyle();
|
||||
};
|
||||
|
||||
// Input mapping structure. Default values listed. See also MapInputDefault, MapInputReverse.
|
||||
struct ImPlotInputMap {
|
||||
ImGuiMouseButton Pan; // LMB enables panning when held,
|
||||
ImGuiKeyModFlags 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
|
||||
ImGuiKeyModFlags SelectMod; // none optional modifier that must be held for box selection
|
||||
ImGuiKeyModFlags SelectHorzMod; // Alt expands active box selection horizontally to plot edge when held
|
||||
ImGuiKeyModFlags SelectVertMod; // Shift expands active box selection vertically to plot edge when held
|
||||
ImGuiMouseButton Menu; // RMB opens context menus (if enabled) when clicked
|
||||
ImGuiKeyModFlags OverrideMod; // Ctrl when held, all input is ignored; used to enable axis/plots as DND sources
|
||||
ImGuiKeyModFlags 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
|
||||
IMPLOT_API ImPlotInputMap();
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// ImPlot End-User API
|
||||
// [SECTION] Callbacks
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Callback signature for axis tick label formatter.
|
||||
typedef void (*ImPlotFormatter)(double value, char* buff, int size, void* user_data);
|
||||
|
||||
// Callback signature for data getter.
|
||||
typedef ImPlotPoint (*ImPlotGetter)(void* user_data, int idx);
|
||||
|
||||
namespace ImPlot {
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// ImPlot Context
|
||||
// [SECTION] Contexts
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Creates a new ImPlot context. Call this after ImGui::CreateContext.
|
||||
|
|
@ -357,14 +442,14 @@ IMPLOT_API void SetCurrentContext(ImPlotContext* ctx);
|
|||
IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Begin/End Plot
|
||||
// [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(...)) {
|
||||
// ImPlot::PlotLine(...);
|
||||
// PlotLine(...);
|
||||
// ...
|
||||
// EndPlot();
|
||||
// }
|
||||
|
|
@ -374,31 +459,16 @@ IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
|
|||
// - #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").
|
||||
// - If #x_label and/or #y_label are provided, axes labels will be displayed.
|
||||
// - #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
|
||||
// (default is 400x300 px).
|
||||
// - Auxiliary y-axes must be enabled with ImPlotFlags_YAxis2/3 to be displayed.
|
||||
// - See ImPlotFlags and ImPlotAxisFlags for more available options.
|
||||
|
||||
IMPLOT_API bool BeginPlot(const char* title_id,
|
||||
const char* x_label = NULL,
|
||||
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 y2_flags = ImPlotAxisFlags_NoGridLines,
|
||||
ImPlotAxisFlags y3_flags = ImPlotAxisFlags_NoGridLines,
|
||||
const char* y2_label = NULL,
|
||||
const char* y3_label = NULL);
|
||||
// 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);
|
||||
|
||||
// Only call EndPlot() if BeginPlot() returns true! Typically called at the end
|
||||
// of an if statement conditioned on BeginPlot(). See example above.
|
||||
IMPLOT_API void EndPlot();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Begin/EndSubplots
|
||||
// [SECTION] Begin/End Subplots
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Starts a subdivided plotting context. If the function returns true,
|
||||
|
|
@ -421,14 +491,15 @@ IMPLOT_API void EndPlot();
|
|||
//
|
||||
// Produces:
|
||||
//
|
||||
// [0][1][2]
|
||||
// [3][4][5]
|
||||
// [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. "MyPlot##HiddenIdText" or "##NoTitle").
|
||||
// (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,
|
||||
|
|
@ -459,10 +530,107 @@ IMPLOT_API bool BeginSubplots(const char* title_id,
|
|||
IMPLOT_API void EndSubplots();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Plot Items
|
||||
// [SECTION] Setup
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The template functions below are explicitly instantiated in implot_items.cpp.
|
||||
// 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 = NULL for no label.
|
||||
IMPLOT_API void SetupAxis(ImAxis axis, const char* label = NULL, ImPlotAxisFlags flags = ImPlotAxisFlags_None);
|
||||
// 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.
|
||||
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);
|
||||
// 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);
|
||||
// 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);
|
||||
|
||||
// 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);
|
||||
// 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);
|
||||
// Set the location of the current plot's mouse position text (default = South|East).
|
||||
IMPLOT_API void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags = ImPlotMouseTextFlags_None);
|
||||
|
||||
// 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.
|
||||
IMPLOT_API void SetupFinish();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [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 anwhere 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.
|
||||
IMPLOT_API void SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlotCond cond = ImPlotCond_Once);
|
||||
// Links an upcoming axis range limits to external values. Set to NULL for no linkage. The pointer data must remain valid until EndPlot!
|
||||
IMPLOT_API void SetNextAxisLinks(ImAxis axis, double* link_min, double* link_max);
|
||||
// Set an upcoming axis to auto fit to its data.
|
||||
IMPLOT_API void SetNextAxisToFit(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).
|
||||
IMPLOT_API void SetNextAxesLimits(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.
|
||||
IMPLOT_API void SetNextAxesToFit();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Plot Items
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The main plotting API is provied 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 templates 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:
|
||||
//
|
||||
|
|
@ -509,33 +677,33 @@ IMPLOT_API void EndSubplots();
|
|||
// Plots a standard 2D line plot.
|
||||
template <typename T> IMPLOT_API void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API 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, ImPlotPoint (*getter)(void* data, int idx), void* data, int count);
|
||||
IMPLOT_API void PlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
|
||||
// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
|
||||
template <typename T> IMPLOT_API void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API 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, ImPlotPoint (*getter)(void* data, int idx), void* data, int count);
|
||||
IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
|
||||
// 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].
|
||||
template <typename T> IMPLOT_API void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API 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, ImPlotPoint (*getter)(void* data, int idx), void* data, int count);
|
||||
IMPLOT_API void PlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
|
||||
// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set y_ref to +/-INFINITY for infinite fill extents.
|
||||
template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* values, int count, double y_ref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API 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, ImPlotPoint (*getter1)(void* data, int idx), void* data1, ImPlotPoint (*getter2)(void* data, int idx), void* data2, int count);
|
||||
IMPLOT_API void PlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count);
|
||||
|
||||
// Plots a vertical bar graph. #width and #shift are in X units.
|
||||
template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* values, int count, double width=0.67, double shift=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double width, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotBarsG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double width);
|
||||
IMPLOT_API void PlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double width);
|
||||
|
||||
// Plots a horizontal bar graph. #height and #shift are in Y units.
|
||||
template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* values, int count, double height=0.67, double shift=0, int offset=0, int stride=sizeof(T));
|
||||
template <typename T> IMPLOT_API void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double height, int offset=0, int stride=sizeof(T));
|
||||
IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, double height);
|
||||
IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotGetter getter, void* data, int count, double height);
|
||||
|
||||
// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
|
||||
template <typename T> IMPLOT_API void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
|
||||
|
|
@ -565,13 +733,13 @@ template <typename T> IMPLOT_API void PlotHeatmap(const char* label_id, const T*
|
|||
template <typename T> IMPLOT_API 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 #range is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #range is specified, outlier values outside of range are not binned.
|
||||
// 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.
|
||||
template <typename T> IMPLOT_API 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, ImPlotLimits range=ImPlotLimits(), bool outliers=true);
|
||||
template <typename T> IMPLOT_API 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 digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
|
||||
template <typename T> IMPLOT_API 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, ImPlotPoint (*getter)(void* data, int idx), void* data, int count);
|
||||
IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count);
|
||||
|
||||
// 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));
|
||||
|
|
@ -583,145 +751,111 @@ IMPLOT_API void PlotText(const char* text, double x, double y, bool vertical=fal
|
|||
IMPLOT_API void PlotDummy(const char* label_id);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Plot Utils
|
||||
// [SECTION] Plot Tools
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The following functions MUST be called BEFORE BeginPlot!
|
||||
// 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`.
|
||||
|
||||
// Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked.
|
||||
IMPLOT_API void SetNextPlotLimits(double xmin, double xmax, double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once);
|
||||
// Set the X axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the X axis limits will be locked.
|
||||
IMPLOT_API void SetNextPlotLimitsX(double xmin, double xmax, ImGuiCond cond = ImGuiCond_Once);
|
||||
// Set the Y axis range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the Y axis limits will be locked.
|
||||
IMPLOT_API void SetNextPlotLimitsY(double ymin, double ymax, ImGuiCond cond = ImGuiCond_Once, ImPlotYAxis y_axis = ImPlotYAxis_1);
|
||||
// Links the next plot limits to external values. Set to NULL for no linkage. The pointer data must remain valid until the matching call to EndPlot.
|
||||
IMPLOT_API void LinkNextPlotLimits(double* xmin, double* xmax, double* ymin, double* ymax, double* ymin2 = NULL, double* ymax2 = NULL, double* ymin3 = NULL, double* ymax3 = NULL);
|
||||
// Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks).
|
||||
IMPLOT_API void FitNextPlotAxes(bool x = true, bool y = true, bool y2 = true, bool y3 = true);
|
||||
// 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);
|
||||
// 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);
|
||||
// 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);
|
||||
// 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);
|
||||
|
||||
// Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
||||
IMPLOT_API void SetNextPlotTicksX(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
|
||||
IMPLOT_API void SetNextPlotTicksX(double x_min, double x_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false);
|
||||
// Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keep_default=true.
|
||||
IMPLOT_API void SetNextPlotTicksY(const double* values, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
|
||||
IMPLOT_API void SetNextPlotTicksY(double y_min, double y_max, int n_ticks, const char* const labels[] = NULL, bool keep_default = false, ImPlotYAxis y_axis = ImPlotYAxis_1);
|
||||
// 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);
|
||||
|
||||
// Set the format for numeric X axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled.
|
||||
IMPLOT_API void SetNextPlotFormatX(const char* fmt);
|
||||
// Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.).
|
||||
IMPLOT_API void SetNextPlotFormatY(const char* fmt, ImPlotYAxis y_axis=ImPlotYAxis_1);
|
||||
// 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);
|
||||
|
||||
// The following functions MUST be called BETWEEN Begin/EndPlot!
|
||||
// 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);
|
||||
|
||||
// Select which Y axis will be used for subsequent plot elements. The default is ImPlotYAxis_1, or the first (left) Y axis. Enable 2nd and 3rd axes with ImPlotFlags_YAxisX.
|
||||
IMPLOT_API void SetPlotYAxis(ImPlotYAxis y_axis);
|
||||
// Hides or shows the next plot item (i.e. as if it were toggled from the legend). Use ImGuiCond_Always if you need to forcefully set this every frame.
|
||||
IMPLOT_API void HideNextItem(bool hidden = true, ImGuiCond cond = ImGuiCond_Once);
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Plot Utils
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Select which axis/axes will be used for subsequent plot elements.
|
||||
IMPLOT_API void SetAxis(ImAxis axis);
|
||||
IMPLOT_API void SetAxes(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.
|
||||
IMPLOT_API ImPlotPoint PixelsToPlot(const ImVec2& pix, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
IMPLOT_API ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
|
||||
// Convert a position in the current plot's coordinate system to pixels. Passing IMPLOT_AUTO uses the current axes.
|
||||
IMPLOT_API ImVec2 PlotToPixels(const ImPlotPoint& plt, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
IMPLOT_API ImVec2 PlotToPixels(double x, double y, ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
|
||||
// Convert pixels to a position in the current plot's coordinate system. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
||||
IMPLOT_API ImPlotPoint PixelsToPlot(const ImVec2& pix, ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
IMPLOT_API ImPlotPoint PixelsToPlot(float x, float y, ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Convert a position in the current plot's coordinate system to pixels. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
||||
IMPLOT_API ImVec2 PlotToPixels(const ImPlotPoint& plt, ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
IMPLOT_API ImVec2 PlotToPixels(double x, double y, ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Get the current Plot position (top-left) in pixels.
|
||||
IMPLOT_API ImVec2 GetPlotPos();
|
||||
// Get the curent Plot size in pixels.
|
||||
IMPLOT_API ImVec2 GetPlotSize();
|
||||
|
||||
// Returns the mouse position in x,y coordinates of the current plot. Passing IMPLOT_AUTO uses the current axes.
|
||||
IMPLOT_API ImPlotPoint GetPlotMousePos(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
// Returns the current plot axis range.
|
||||
IMPLOT_API ImPlotRect GetPlotLimits(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
|
||||
// Returns true if the plot area in the current plot is hovered.
|
||||
IMPLOT_API bool IsPlotHovered();
|
||||
// Returns true if the XAxis plot area in the current plot is hovered.
|
||||
IMPLOT_API bool IsPlotXAxisHovered();
|
||||
// Returns true if the YAxis[n] plot area in the current plot is hovered.
|
||||
IMPLOT_API bool IsPlotYAxisHovered(ImPlotYAxis y_axis = 0);
|
||||
// Returns the mouse position in x,y coordinates of the current plot. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
||||
IMPLOT_API ImPlotPoint GetPlotMousePos(ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Returns the current plot axis range. A negative y_axis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially).
|
||||
IMPLOT_API ImPlotLimits GetPlotLimits(ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Returns true if the axis label area in the current plot is hovered.
|
||||
IMPLOT_API bool IsAxisHovered(ImAxis axis);
|
||||
// Returns true if the bounding frame of a subplot is hovered.
|
||||
IMPLOT_API bool IsSubplotsHovered();
|
||||
|
||||
// Returns true if the current plot is being box selected.
|
||||
IMPLOT_API bool IsPlotSelected();
|
||||
// Returns the current plot box selection bounds.
|
||||
IMPLOT_API ImPlotLimits GetPlotSelection(ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Returns the current plot box selection bounds. Passing IMPLOT_AUTO uses the current axes.
|
||||
IMPLOT_API ImPlotRect GetPlotSelection(ImAxis x_axis = IMPLOT_AUTO, ImAxis y_axis = IMPLOT_AUTO);
|
||||
// Cancels a the current plot box selection.
|
||||
IMPLOT_API void CancelPlotSelection();
|
||||
|
||||
// Returns true if the current plot is being queried or has an active query. Query must be enabled with ImPlotFlags_Query.
|
||||
IMPLOT_API bool IsPlotQueried();
|
||||
// Returns the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
|
||||
IMPLOT_API ImPlotLimits GetPlotQuery(ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
// Set the current plot query bounds. Query must be enabled with ImPlotFlags_Query.
|
||||
IMPLOT_API void SetPlotQuery(const ImPlotLimits& query, ImPlotYAxis y_axis = IMPLOT_AUTO);
|
||||
|
||||
// Returns true if the bounding frame of a subplot is hovered/
|
||||
IMPLOT_API bool IsSubplotsHovered();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Aligned Plots
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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.
|
||||
IMPLOT_API void HideNextItem(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. If this function returns true, EndAlignedPlots() must be called. #group_id must be unique.
|
||||
IMPLOT_API bool BeginAlignedPlots(const char* group_id, ImPlotOrientation orientation = ImPlotOrientation_Vertical);
|
||||
// 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.
|
||||
IMPLOT_API bool BeginAlignedPlots(const char* group_id, bool vertical = true);
|
||||
// Only call EndAlignedPlots() if BeginAlignedPlots() returns true!
|
||||
IMPLOT_API void EndAlignedPlots();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Plot Tools
|
||||
// [SECTION] Legend Utils
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The following functions MUST be called BETWEEN Begin/EndPlot!
|
||||
|
||||
// Shows an annotation callout at a chosen point.
|
||||
IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const char* fmt, ...) IM_FMTARGS(4);
|
||||
IMPLOT_API void Annotate(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(5);
|
||||
IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args) IM_FMTLIST(4);
|
||||
IMPLOT_API void AnnotateV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(5);
|
||||
|
||||
// Same as above, but the annotation will always be clamped to stay inside the plot area.
|
||||
IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const char* fmt, ...) IM_FMTARGS(4);
|
||||
IMPLOT_API void AnnotateClamped(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, ...) IM_FMTARGS(5);
|
||||
IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const char* fmt, va_list args) IM_FMTLIST(4);
|
||||
IMPLOT_API void AnnotateClampedV(double x, double y, const ImVec2& pix_offset, const ImVec4& color, const char* fmt, va_list args) IM_FMTLIST(5);
|
||||
|
||||
// Shows a draggable vertical guide line at an x-value. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragLineX(const char* id, double* x_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
|
||||
// Shows a draggable horizontal guide line at a y-value. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragLineY(const char* id, double* y_value, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1);
|
||||
// Shows a draggable point at x,y. #col defaults to ImGuiCol_Text.
|
||||
IMPLOT_API bool DragPoint(const char* id, double* x, double* y, bool show_label = true, const ImVec4& col = IMPLOT_AUTO_COL, float radius = 4);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Legend Utils and Tools
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The following functions MUST be called BETWEEN Begin/EndPlot!
|
||||
|
||||
// Set the location of the current plot's (or subplot's) legend.
|
||||
IMPLOT_API void SetLegendLocation(ImPlotLocation location, ImPlotOrientation orientation = ImPlotOrientation_Vertical, bool outside = false);
|
||||
// Set the location of the current plot's mouse position text (default = South|East).
|
||||
IMPLOT_API void SetMousePosLocation(ImPlotLocation location);
|
||||
// Returns true if a plot item legend entry is hovered.
|
||||
IMPLOT_API bool IsLegendEntryHovered(const char* label_id);
|
||||
|
||||
// Begin a popup for a legend entry.
|
||||
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.
|
||||
IMPLOT_API bool IsLegendEntryHovered(const char* label_id);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Drag and Drop Utils
|
||||
// [SECTION] Drag and Drop
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// The following functions MUST be called BETWEEN Begin/EndPlot!
|
||||
|
||||
// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
|
||||
IMPLOT_API bool BeginDragDropTarget();
|
||||
IMPLOT_API bool BeginDragDropTargetPlot();
|
||||
// Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget!
|
||||
IMPLOT_API bool BeginDragDropTargetX();
|
||||
// Turns the current plot's Y-Axis into a drag and drop target. Don't forget to call EndDragDropTarget!
|
||||
IMPLOT_API bool BeginDragDropTargetY(ImPlotYAxis axis = ImPlotYAxis_1);
|
||||
IMPLOT_API bool BeginDragDropTargetAxis(ImAxis axis);
|
||||
// Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget!
|
||||
IMPLOT_API bool BeginDragDropTargetLegend();
|
||||
// Ends a drag and drop target (currently just an alias for ImGui::EndDragDropTarget).
|
||||
|
|
@ -730,19 +864,17 @@ IMPLOT_API void EndDragDropTarget();
|
|||
// 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 ImGuiKeyModFlags_None is provided, the axes will be locked from panning.
|
||||
|
||||
// Turns the current plot's plotting area into a drag and drop source. Don't forget to call EndDragDropSource!
|
||||
IMPLOT_API bool BeginDragDropSource(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
|
||||
// Turns the current plot's X-axis into a drag and drop source. Don't forget to call EndDragDropSource!
|
||||
IMPLOT_API bool BeginDragDropSourceX(ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
|
||||
// Turns the current plot's Y-axis into a drag and drop source. Don't forget to call EndDragDropSource!
|
||||
IMPLOT_API bool BeginDragDropSourceY(ImPlotYAxis axis = ImPlotYAxis_1, ImGuiKeyModFlags key_mods = ImGuiKeyModFlags_Ctrl, ImGuiDragDropFlags flags = 0);
|
||||
// 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);
|
||||
// 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);
|
||||
// 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);
|
||||
// Ends a drag and drop source (currently just an alias for ImGui::EndDragDropSource).
|
||||
IMPLOT_API void EndDragDropSource();
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Plot and Item Styling
|
||||
// [SECTION] Styling
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Styling colors in ImPlot works similarly to styling colors in ImGui, but
|
||||
|
|
@ -828,7 +960,7 @@ IMPLOT_API const char* GetStyleColorName(ImPlotCol idx);
|
|||
IMPLOT_API const char* GetMarkerName(ImPlotMarker idx);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Colormaps
|
||||
// [SECTION] Colormaps
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
|
||||
|
|
@ -878,7 +1010,7 @@ IMPLOT_API ImVec4 GetColormapColor(int idx, ImPlotColormap cmap = IMPLOT_AUTO);
|
|||
IMPLOT_API ImVec4 SampleColormap(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").
|
||||
IMPLOT_API void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO, const char* fmt = "%g");
|
||||
IMPLOT_API void ColormapScale(const char* label, double scale_min, double scale_max, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO, const char* format = "%g");
|
||||
// Shows a horizontal slider with a colormap gradient background. Optionally returns the color sampled at t in [0 1].
|
||||
IMPLOT_API bool ColormapSlider(const char* label, float* t, ImVec4* out = NULL, const char* format = "", ImPlotColormap cmap = IMPLOT_AUTO);
|
||||
// Shows a button with a colormap gradient brackground.
|
||||
|
|
@ -894,7 +1026,19 @@ IMPLOT_API bool ColormapButton(const char* label, const ImVec2& size = ImVec2(0,
|
|||
IMPLOT_API void BustColorCache(const char* plot_title_id = NULL);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Miscellaneous
|
||||
// [SECTION] Input Mapping
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Provides access to input mapping structure for permanant modifications to controls for pan, select, etc.
|
||||
IMPLOT_API ImPlotInputMap& GetInputMap();
|
||||
|
||||
// Default input mapping: pan = LMB drag, box select = RMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
|
||||
IMPLOT_API void MapInputDefault(ImPlotInputMap* dst = NULL);
|
||||
// Reverse input mapping: pan = RMB drag, box select = LMB drag, fit = LMB double click, context menu = RMB click, zoom = scroll.
|
||||
IMPLOT_API void MapInputReverse(ImPlotInputMap* dst = NULL);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [SECTION] Miscellaneous
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Render icons similar to those that appear in legends (nifty for data lists).
|
||||
|
|
@ -913,6 +1057,8 @@ IMPLOT_API void PopPlotClipRect();
|
|||
IMPLOT_API bool ShowStyleSelector(const char* label);
|
||||
// Shows ImPlot colormap selector dropdown menu.
|
||||
IMPLOT_API bool ShowColormapSelector(const char* label);
|
||||
// Shows ImPlot input map selector dropdown menu.
|
||||
IMPLOT_API bool ShowInputMapSelector(const char* label);
|
||||
// Shows ImPlot style editor block (not a window).
|
||||
IMPLOT_API void ShowStyleEditor(ImPlotStyle* ref = NULL);
|
||||
// Add basic help/info block for end users (not a window).
|
||||
|
|
@ -921,10 +1067,59 @@ IMPLOT_API void ShowUserGuide();
|
|||
IMPLOT_API void ShowMetricsWindow(bool* p_popen = NULL);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Demo (add implot_demo.cpp to your sources!)
|
||||
// [SECTION] Demo
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// Shows the ImPlot demo window.
|
||||
// Shows the ImPlot demo window (add implot_demo.cpp to your sources!)
|
||||
IMPLOT_API void ShowDemoWindow(bool* p_open = NULL);
|
||||
|
||||
} // namespace ImPlot
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// [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
|
||||
#elif defined( __GNUC__ ) && !defined( __INTEL_COMPILER ) && ( __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) )
|
||||
#define IMPLOT_DEPRECATED(method) method __attribute__( ( deprecated ) )
|
||||
#elif defined( _MSC_VER )
|
||||
#define IMPLOT_DEPRECATED(method) __declspec(deprecated) method
|
||||
#else
|
||||
#define IMPLOT_DEPRECATED(method) method
|
||||
#endif
|
||||
#else
|
||||
#define IMPLOT_DEPRECATED(method) method
|
||||
#endif
|
||||
|
||||
enum ImPlotFlagsObsolete_ {
|
||||
ImPlotFlags_YAxis2 = 1 << 10,
|
||||
ImPlotFlags_YAxis3 = 1 << 11,
|
||||
};
|
||||
|
||||
namespace ImPlot {
|
||||
|
||||
// OBSOLETED in v0.13 -> PLANNED REMOVAL in v1.0
|
||||
IMPLOT_DEPRECATED( IMPLOT_API bool BeginPlot(const char* title_id,
|
||||
const char* x_label, // = NULL,
|
||||
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 y2_flags = ImPlotAxisFlags_AuxDefault,
|
||||
ImPlotAxisFlags y3_flags = ImPlotAxisFlags_AuxDefault,
|
||||
const char* y2_label = NULL,
|
||||
const char* y3_label = NULL) );
|
||||
|
||||
} // namespace ImPlot
|
||||
|
||||
#endif
|
||||
|
|
|
|||
837
implot_demo.cpp
837
implot_demo.cpp
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
194
implot_items.cpp
194
implot_items.cpp
|
|
@ -20,7 +20,7 @@
|
|||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
// ImPlot v0.12 WIP
|
||||
// ImPlot v0.13 WIP
|
||||
|
||||
#include "implot.h"
|
||||
#include "implot_internal.h"
|
||||
|
|
@ -150,13 +150,6 @@ ImVec4 GetLastItemColor() {
|
|||
return ImVec4();
|
||||
}
|
||||
|
||||
void HideNextItem(bool hidden, ImGuiCond cond) {
|
||||
ImPlotContext& gp = *GImPlot;
|
||||
gp.NextItemData.HasHidden = true;
|
||||
gp.NextItemData.Hidden = hidden;
|
||||
gp.NextItemData.HiddenCond = cond;
|
||||
}
|
||||
|
||||
void BustItemCache() {
|
||||
ImPlotContext& gp = *GImPlot;
|
||||
for (int p = 0; p < gp.Plots.GetBufSize(); ++p) {
|
||||
|
|
@ -191,10 +184,14 @@ void BustColorCache(const char* plot_title_id) {
|
|||
// Begin/EndItem
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const float ITEM_HIGHLIGHT_LINE_SCALE = 2.0f;
|
||||
static const float ITEM_HIGHLIGHT_MARK_SCALE = 1.25f;
|
||||
|
||||
// Begins a new item. Returns false if the item should not be plotted.
|
||||
bool BeginItem(const char* label_id, ImPlotCol recolor_from) {
|
||||
ImPlotContext& gp = *GImPlot;
|
||||
IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotX() needs to be called between BeginPlot() and EndPlot()!");
|
||||
SetupLock();
|
||||
bool just_created;
|
||||
ImPlotItem* item = RegisterOrGetItem(label_id, &just_created);
|
||||
// set current item
|
||||
|
|
@ -244,12 +241,21 @@ bool BeginItem(const char* label_id, ImPlotCol recolor_from) {
|
|||
s.DigitalBitGap = s.DigitalBitGap < 0 ? gp.Style.DigitalBitGap : s.DigitalBitGap;
|
||||
// apply alpha modifier(s)
|
||||
s.Colors[ImPlotCol_Fill].w *= s.FillAlpha;
|
||||
// s.Colors[ImPlotCol_MarkerFill].w *= s.FillAlpha; // TODO: this should be separate, if it at all
|
||||
s.Colors[ImPlotCol_MarkerFill].w *= s.FillAlpha; // TODO: this should be separate, if it at all
|
||||
// apply highlight mods
|
||||
if (item->LegendHovered && !ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_NoHighlight)) {
|
||||
s.LineWeight *= 2;
|
||||
s.MarkerWeight *= 2;
|
||||
// TODO: highlight fills?
|
||||
if (item->LegendHovered) {
|
||||
if (!ImHasFlag(gp.CurrentItems->Legend.Flags, ImPlotLegendFlags_NoHighlightItem)) {
|
||||
s.LineWeight *= ITEM_HIGHLIGHT_LINE_SCALE;
|
||||
s.MarkerSize *= ITEM_HIGHLIGHT_MARK_SCALE;
|
||||
s.MarkerWeight *= ITEM_HIGHLIGHT_LINE_SCALE;
|
||||
// TODO: how to highlight fills?
|
||||
}
|
||||
if (!ImHasFlag(gp.CurrentItems->Legend.Flags, ImPlotLegendFlags_NoHighlightAxis)) {
|
||||
if (gp.CurrentPlot->EnabledAxesX() > 1)
|
||||
gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentX].ColorHiLi = item->Color;
|
||||
if (gp.CurrentPlot->EnabledAxesY() > 1)
|
||||
gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentY].ColorHiLi = item->Color;
|
||||
}
|
||||
}
|
||||
// set render flags
|
||||
s.RenderLine = s.Colors[ImPlotCol_Line].w > 0 && s.LineWeight > 0;
|
||||
|
|
@ -477,18 +483,34 @@ struct TransformerLog {
|
|||
|
||||
template <typename TransformerX, typename TransformerY>
|
||||
struct TransformerXY {
|
||||
TransformerXY() :
|
||||
YAxis(GetCurrentYAxis()),
|
||||
Tx(GImPlot->PixelRange[YAxis].Min.x, GImPlot->CurrentPlot->XAxis.Range.Min, GImPlot->CurrentPlot->XAxis.Range.Max, GImPlot->Mx, GImPlot->LogDenX),
|
||||
Ty(GImPlot->PixelRange[YAxis].Min.y, GImPlot->CurrentPlot->YAxis[YAxis].Range.Min, GImPlot->CurrentPlot->YAxis[YAxis].Range.Max, GImPlot->My[YAxis], GImPlot->LogDenY[YAxis])
|
||||
TransformerXY(const ImPlotAxis& x_axis, const ImPlotAxis& y_axis) :
|
||||
|
||||
Tx(x_axis.PixelMin,
|
||||
x_axis.Range.Min,
|
||||
x_axis.Range.Max,
|
||||
x_axis.LinM,
|
||||
x_axis.LogD),
|
||||
Ty(y_axis.PixelMin,
|
||||
y_axis.Range.Min,
|
||||
y_axis.Range.Max,
|
||||
y_axis.LinM,
|
||||
y_axis.LogD)
|
||||
{ }
|
||||
|
||||
TransformerXY(const ImPlotPlot& plot) :
|
||||
TransformerXY(plot.Axes[plot.CurrentX], plot.Axes[plot.CurrentY])
|
||||
{ }
|
||||
|
||||
TransformerXY() :
|
||||
TransformerXY(*GImPlot->CurrentPlot)
|
||||
{ }
|
||||
|
||||
template <typename P> IMPLOT_INLINE ImVec2 operator()(const P& plt) const {
|
||||
ImVec2 out;
|
||||
out.x = Tx(plt.x);
|
||||
out.y = Ty(plt.y);
|
||||
return out;
|
||||
}
|
||||
int YAxis;
|
||||
TransformerX Tx;
|
||||
TransformerY Ty;
|
||||
};
|
||||
|
|
@ -945,8 +967,9 @@ IMPLOT_INLINE void PlotLineEx(const char* label_id, const Getter& getter) {
|
|||
}
|
||||
// render markers
|
||||
if (s.Marker != ImPlotMarker_None) {
|
||||
PopPlotClipRect();
|
||||
PushPlotClipRect(s.MarkerSize);
|
||||
// uncomment lines below to render markers over plot rect border
|
||||
// PopPlotClipRect();
|
||||
// PushPlotClipRect(s.MarkerSize);
|
||||
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
|
||||
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
|
||||
switch (GetCurrentScale()) {
|
||||
|
|
@ -996,7 +1019,7 @@ template IMPLOT_API void PlotLine<float>(const char* label_id, const float* xs,
|
|||
template IMPLOT_API void PlotLine<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotLineG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count) {
|
||||
void PlotLineG(const char* label_id, ImPlotGetter getter_func, void* data, int count) {
|
||||
GetterFuncPtr getter(getter_func,data, count);
|
||||
return PlotLineEx(label_id, getter);
|
||||
}
|
||||
|
|
@ -1019,8 +1042,9 @@ IMPLOT_INLINE void PlotScatterEx(const char* label_id, const Getter& getter) {
|
|||
// render markers
|
||||
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
|
||||
if (marker != ImPlotMarker_None) {
|
||||
PopPlotClipRect();
|
||||
PushPlotClipRect(s.MarkerSize);
|
||||
// uncomment lines below to render markers over plot rect border
|
||||
// PopPlotClipRect();
|
||||
// PushPlotClipRect(s.MarkerSize);
|
||||
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
|
||||
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
|
||||
switch (GetCurrentScale()) {
|
||||
|
|
@ -1069,7 +1093,7 @@ template IMPLOT_API void PlotScatter<float>(const char* label_id, const float* x
|
|||
template IMPLOT_API void PlotScatter<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotScatterG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count) {
|
||||
void PlotScatterG(const char* label_id, ImPlotGetter getter_func, void* data, int count) {
|
||||
GetterFuncPtr getter(getter_func,data, count);
|
||||
return PlotScatterEx(label_id, getter);
|
||||
}
|
||||
|
|
@ -1150,7 +1174,7 @@ template IMPLOT_API void PlotStairs<float>(const char* label_id, const float* xs
|
|||
template IMPLOT_API void PlotStairs<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotStairsG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count) {
|
||||
void PlotStairsG(const char* label_id, ImPlotGetter getter_func, void* data, int count) {
|
||||
GetterFuncPtr getter(getter_func,data, count);
|
||||
return PlotStairsEx(label_id, getter);
|
||||
}
|
||||
|
|
@ -1190,11 +1214,11 @@ void PlotShaded(const char* label_id, const T* values, int count, double y_ref,
|
|||
bool fit2 = true;
|
||||
if (y_ref == -HUGE_VAL) {
|
||||
fit2 = false;
|
||||
y_ref = GetPlotLimits().Y.Min;
|
||||
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Min;
|
||||
}
|
||||
if (y_ref == HUGE_VAL) {
|
||||
fit2 = false;
|
||||
y_ref = GetPlotLimits().Y.Max;
|
||||
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Max;
|
||||
}
|
||||
GetterYs<T> getter1(values,count,xscale,x0,offset,stride);
|
||||
GetterYRef getter2(y_ref,count,xscale,x0);
|
||||
|
|
@ -1217,11 +1241,11 @@ void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, doubl
|
|||
bool fit2 = true;
|
||||
if (y_ref == -HUGE_VAL) {
|
||||
fit2 = false;
|
||||
y_ref = GetPlotLimits().Y.Min;
|
||||
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Min;
|
||||
}
|
||||
if (y_ref == HUGE_VAL) {
|
||||
fit2 = false;
|
||||
y_ref = GetPlotLimits().Y.Max;
|
||||
y_ref = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO).Y.Max;
|
||||
}
|
||||
GetterXsYs<T> getter1(xs, ys, count, offset, stride);
|
||||
GetterXsYRef<T> getter2(xs, y_ref, count, offset, stride);
|
||||
|
|
@ -1258,9 +1282,9 @@ template IMPLOT_API void PlotShaded<float>(const char* label_id, const float* xs
|
|||
template IMPLOT_API void PlotShaded<double>(const char* label_id, const double* xs, const double* ys1, const double* ys2, int count, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotShadedG(const char* label_id, ImPlotPoint (*g1)(void* data, int idx), void* data1, ImPlotPoint (*g2)(void* data, int idx), void* data2, int count) {
|
||||
GetterFuncPtr getter1(g1, data1, count);
|
||||
GetterFuncPtr getter2(g2, data2, count);
|
||||
void PlotShadedG(const char* label_id, ImPlotGetter getter_func1, void* data1, ImPlotGetter getter_func2, void* data2, int count) {
|
||||
GetterFuncPtr getter1(getter_func1, data1, count);
|
||||
GetterFuncPtr getter2(getter_func2, data2, count);
|
||||
PlotShadedEx(label_id, getter1, getter2, true);
|
||||
}
|
||||
|
||||
|
|
@ -1292,8 +1316,8 @@ void PlotBarsEx(const char* label_id, const Getter& getter, double width) {
|
|||
ImPlotPoint p = getter(i);
|
||||
if (p.y == 0)
|
||||
continue;
|
||||
ImVec2 a = PlotToPixels(p.x - half_width, p.y);
|
||||
ImVec2 b = PlotToPixels(p.x + half_width, 0);
|
||||
ImVec2 a = PlotToPixels(p.x - half_width, p.y,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 b = PlotToPixels(p.x + half_width, 0,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
float width_px = ImAbs(a.x-b.x);
|
||||
if (width_px < 1.0f) {
|
||||
a.x += a.x > b.x ? (1-width_px) / 2 : (width_px-1) / 2;
|
||||
|
|
@ -1345,7 +1369,7 @@ template IMPLOT_API void PlotBars<float>(const char* label_id, const float* xs,
|
|||
template IMPLOT_API void PlotBars<double>(const char* label_id, const double* xs, const double* ys, int count, double width, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotBarsG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double width) {
|
||||
void PlotBarsG(const char* label_id, ImPlotGetter getter_func, void* data, int count, double width) {
|
||||
GetterFuncPtr getter(getter_func, data, count);
|
||||
PlotBarsEx(label_id, getter, width);
|
||||
}
|
||||
|
|
@ -1378,8 +1402,8 @@ void PlotBarsHEx(const char* label_id, const Getter& getter, THeight height) {
|
|||
ImPlotPoint p = getter(i);
|
||||
if (p.x == 0)
|
||||
continue;
|
||||
ImVec2 a = PlotToPixels(0, p.y - half_height);
|
||||
ImVec2 b = PlotToPixels(p.x, p.y + half_height);
|
||||
ImVec2 a = PlotToPixels(0, p.y - half_height,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 b = PlotToPixels(p.x, p.y + half_height,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
if (s.RenderFill)
|
||||
DrawList.AddRectFilled(a, b, col_fill);
|
||||
if (rend_line)
|
||||
|
|
@ -1424,7 +1448,7 @@ template IMPLOT_API void PlotBarsH<float>(const char* label_id, const float* xs,
|
|||
template IMPLOT_API void PlotBarsH<double>(const char* label_id, const double* xs, const double* ys, int count, double height, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotBarsHG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count, double height) {
|
||||
void PlotBarsHG(const char* label_id, ImPlotGetter getter_func, void* data, int count, double height) {
|
||||
GetterFuncPtr getter(getter_func, data, count);
|
||||
PlotBarsHEx(label_id, getter, height);
|
||||
}
|
||||
|
|
@ -1450,8 +1474,8 @@ void PlotErrorBarsEx(const char* label_id, const Getter& getter) {
|
|||
const float half_whisker = s.ErrorBarSize * 0.5f;
|
||||
for (int i = 0; i < getter.Count; ++i) {
|
||||
ImPlotPointError e = getter(i);
|
||||
ImVec2 p1 = PlotToPixels(e.X, e.Y - e.Neg);
|
||||
ImVec2 p2 = PlotToPixels(e.X, e.Y + e.Pos);
|
||||
ImVec2 p1 = PlotToPixels(e.X, e.Y - e.Neg,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 p2 = PlotToPixels(e.X, e.Y + e.Pos,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
DrawList.AddLine(p1,p2,col, s.ErrorBarWeight);
|
||||
if (rend_whisker) {
|
||||
DrawList.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
|
||||
|
|
@ -1517,8 +1541,8 @@ void PlotErrorBarsHEx(const char* label_id, const Getter& getter) {
|
|||
const float half_whisker = s.ErrorBarSize * 0.5f;
|
||||
for (int i = 0; i < getter.Count; ++i) {
|
||||
ImPlotPointError e = getter(i);
|
||||
ImVec2 p1 = PlotToPixels(e.X - e.Neg, e.Y);
|
||||
ImVec2 p2 = PlotToPixels(e.X + e.Pos, e.Y);
|
||||
ImVec2 p1 = PlotToPixels(e.X - e.Neg, e.Y,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 p2 = PlotToPixels(e.X + e.Pos, e.Y,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
DrawList.AddLine(p1, p2, col, s.ErrorBarWeight);
|
||||
if (rend_whisker) {
|
||||
DrawList.AddLine(p1 - ImVec2(0, half_whisker), p1 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
|
||||
|
|
@ -1649,7 +1673,7 @@ template IMPLOT_API void PlotStems<double>(const char* label_id, const double* x
|
|||
template <typename T>
|
||||
void PlotVLines(const char* label_id, const T* xs, int count, int offset, int stride) {
|
||||
if (BeginItem(label_id, ImPlotCol_Line)) {
|
||||
const ImPlotLimits lims = GetPlotLimits();
|
||||
const ImPlotRect lims = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
GetterXsYRef<T> get_min(xs,lims.Y.Min,count,offset,stride);
|
||||
GetterXsYRef<T> get_max(xs,lims.Y.Max,count,offset,stride);
|
||||
if (FitThisFrame()) {
|
||||
|
|
@ -1687,7 +1711,7 @@ template IMPLOT_API void PlotVLines<double>(const char* label_id, const double*
|
|||
template <typename T>
|
||||
void PlotHLines(const char* label_id, const T* ys, int count, int offset, int stride) {
|
||||
if (BeginItem(label_id, ImPlotCol_Line)) {
|
||||
const ImPlotLimits lims = GetPlotLimits();
|
||||
const ImPlotRect lims = GetPlotLimits(IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
GetterXRefYs<T> get_min(lims.X.Min,ys,count,offset,stride);
|
||||
GetterXRefYs<T> get_max(lims.X.Max,ys,count,offset,stride);
|
||||
if (FitThisFrame()) {
|
||||
|
|
@ -1728,12 +1752,12 @@ template IMPLOT_API void PlotHLines<double>(const char* label_id, const double*
|
|||
IMPLOT_INLINE void RenderPieSlice(ImDrawList& DrawList, const ImPlotPoint& center, double radius, double a0, double a1, ImU32 col) {
|
||||
static const float resolution = 50 / (2 * IM_PI);
|
||||
static ImVec2 buffer[50];
|
||||
buffer[0] = PlotToPixels(center);
|
||||
buffer[0] = PlotToPixels(center,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
int n = ImMax(3, (int)((a1 - a0) * resolution));
|
||||
double da = (a1 - a0) / (n - 1);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
double a = a0 + i * da;
|
||||
buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a));
|
||||
buffer[i + 1] = PlotToPixels(center.x + radius * cos(a), center.y + radius * sin(a),IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
}
|
||||
DrawList.AddConvexPolyFilled(buffer, n + 1, col);
|
||||
}
|
||||
|
|
@ -1782,7 +1806,7 @@ void PlotPieChart(const char* const label_ids[], const T* values, int count, dou
|
|||
sprintf(buffer, fmt, (double)values[i]);
|
||||
ImVec2 size = ImGui::CalcTextSize(buffer);
|
||||
double angle = a0 + (a1 - a0) * 0.5;
|
||||
ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle));
|
||||
ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle),IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImU32 col = CalcTextColor(ImGui::ColorConvertU32ToFloat4(item->Color));
|
||||
DrawList.AddText(pos - size * 0.5f, col, buffer);
|
||||
}
|
||||
|
|
@ -1997,8 +2021,8 @@ double PlotHistogram(const char* label_id, const T* values, int count, int bins,
|
|||
else
|
||||
width = range.Size() / bins;
|
||||
|
||||
ImVector<double>& bin_centers = GImPlot->Temp1;
|
||||
ImVector<double>& bin_counts = GImPlot->Temp2;
|
||||
ImVector<double>& bin_centers = GImPlot->TempDouble1;
|
||||
ImVector<double>& bin_counts = GImPlot->TempDouble2;
|
||||
bin_centers.resize(bins);
|
||||
bin_counts.resize(bins);
|
||||
int below = 0;
|
||||
|
|
@ -2065,7 +2089,7 @@ template IMPLOT_API double PlotHistogram<double>(const char* label_id, const dou
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
template <typename T>
|
||||
double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers) {
|
||||
double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers) {
|
||||
|
||||
if (count <= 0 || x_bins == 0 || y_bins == 0)
|
||||
return 0;
|
||||
|
|
@ -2095,7 +2119,7 @@ double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count
|
|||
|
||||
const int bins = x_bins * y_bins;
|
||||
|
||||
ImVector<double>& bin_counts = GImPlot->Temp1;
|
||||
ImVector<double>& bin_counts = GImPlot->TempDouble1;
|
||||
bin_counts.resize(bins);
|
||||
|
||||
for (int b = 0; b < bins; ++b)
|
||||
|
|
@ -2138,16 +2162,16 @@ double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count
|
|||
return max_count;
|
||||
}
|
||||
|
||||
template IMPLOT_API double PlotHistogram2D<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<float>(const char* label_id, const float* xs, const float* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<double>(const char* label_id, const double* xs, const double* ys, int count, int x_bins, int y_bins, bool density, ImPlotLimits range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS8>(const char* label_id, const ImS8* xs, const ImS8* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU8>(const char* label_id, const ImU8* xs, const ImU8* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS16>(const char* label_id, const ImS16* xs, const ImS16* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU16>(const char* label_id, const ImU16* xs, const ImU16* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS32>(const char* label_id, const ImS32* xs, const ImS32* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU32>(const char* label_id, const ImU32* xs, const ImU32* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImS64>(const char* label_id, const ImS64* xs, const ImS64* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<ImU64>(const char* label_id, const ImU64* xs, const ImU64* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<float>(const char* label_id, const float* xs, const float* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
template IMPLOT_API double PlotHistogram2D<double>(const char* label_id, const double* xs, const double* ys, int count, int x_bins, int y_bins, bool density, ImPlotRect range, bool outliers);
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// PLOT DIGITAL
|
||||
|
|
@ -2162,7 +2186,10 @@ IMPLOT_INLINE void PlotDigitalEx(const char* label_id, Getter getter) {
|
|||
ImDrawList& DrawList = *GetPlotDrawList();
|
||||
const ImPlotNextItemData& s = GetItemData();
|
||||
if (getter.Count > 1 && s.RenderFill) {
|
||||
const int y_axis = GetCurrentYAxis();
|
||||
ImPlotPlot& plot = *gp.CurrentPlot;
|
||||
ImPlotAxis& x_axis = plot.Axes[plot.CurrentX];
|
||||
ImPlotAxis& y_axis = plot.Axes[plot.CurrentY];
|
||||
|
||||
int pixYMax = 0;
|
||||
ImPlotPoint itemData1 = getter(0);
|
||||
for (int i = 0; i < getter.Count; ++i) {
|
||||
|
|
@ -2178,24 +2205,24 @@ IMPLOT_INLINE void PlotDigitalEx(const char* label_id, Getter getter) {
|
|||
int pixY_1 = (int)(pixY_1_float); //allow only positive values
|
||||
int pixY_chPosOffset = (int)(ImMax(s.DigitalBitHeight, pixY_1_float) + s.DigitalBitGap);
|
||||
pixYMax = ImMax(pixYMax, pixY_chPosOffset);
|
||||
ImVec2 pMin = PlotToPixels(itemData1);
|
||||
ImVec2 pMax = PlotToPixels(itemData2);
|
||||
int pixY_Offset = 20; //20 pixel from bottom due to mouse cursor label
|
||||
pMin.y = (gp.PixelRange[y_axis].Min.y) + ((-gp.DigitalPlotOffset) - pixY_Offset);
|
||||
pMax.y = (gp.PixelRange[y_axis].Min.y) + ((-gp.DigitalPlotOffset) - pixY_0 - pixY_1 - pixY_Offset);
|
||||
ImVec2 pMin = PlotToPixels(itemData1,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 pMax = PlotToPixels(itemData2,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
int pixY_Offset = 0; //20 pixel from bottom due to mouse cursor label
|
||||
pMin.y = (y_axis.PixelMin) + ((-gp.DigitalPlotOffset) - pixY_Offset);
|
||||
pMax.y = (y_axis.PixelMin) + ((-gp.DigitalPlotOffset) - pixY_0 - pixY_1 - pixY_Offset);
|
||||
//plot only one rectangle for same digital state
|
||||
while (((i+2) < getter.Count) && (itemData1.y == itemData2.y)) {
|
||||
const int in = (i + 1);
|
||||
itemData2 = getter(in);
|
||||
if (ImNanOrInf(itemData2.y)) break;
|
||||
pMax.x = PlotToPixels(itemData2).x;
|
||||
pMax.x = PlotToPixels(itemData2,IMPLOT_AUTO,IMPLOT_AUTO).x;
|
||||
i++;
|
||||
}
|
||||
//do not extend plot outside plot range
|
||||
if (pMin.x < gp.PixelRange[y_axis].Min.x) pMin.x = gp.PixelRange[y_axis].Min.x;
|
||||
if (pMax.x < gp.PixelRange[y_axis].Min.x) pMax.x = gp.PixelRange[y_axis].Min.x;
|
||||
if (pMin.x > gp.PixelRange[y_axis].Max.x) pMin.x = gp.PixelRange[y_axis].Max.x;
|
||||
if (pMax.x > gp.PixelRange[y_axis].Max.x) pMax.x = gp.PixelRange[y_axis].Max.x;
|
||||
if (pMin.x < x_axis.PixelMin) pMin.x = x_axis.PixelMin;
|
||||
if (pMax.x < x_axis.PixelMin) pMax.x = x_axis.PixelMin;
|
||||
if (pMin.x > x_axis.PixelMax) pMin.x = x_axis.PixelMax;
|
||||
if (pMax.x > x_axis.PixelMax) pMax.x = x_axis.PixelMax;
|
||||
//plot a rectangle that extends up to x2 with y1 height
|
||||
if ((pMax.x > pMin.x) && (gp.CurrentPlot->PlotRect.Contains(pMin) || gp.CurrentPlot->PlotRect.Contains(pMax))) {
|
||||
// ImVec4 colAlpha = item->Color;
|
||||
|
|
@ -2230,7 +2257,7 @@ template IMPLOT_API void PlotDigital<float>(const char* label_id, const float* x
|
|||
template IMPLOT_API void PlotDigital<double>(const char* label_id, const double* xs, const double* ys, int count, int offset, int stride);
|
||||
|
||||
// custom
|
||||
void PlotDigitalG(const char* label_id, ImPlotPoint (*getter_func)(void* data, int idx), void* data, int count) {
|
||||
void PlotDigitalG(const char* label_id, ImPlotGetter getter_func, void* data, int count) {
|
||||
GetterFuncPtr getter(getter_func,data,count);
|
||||
return PlotDigitalEx(label_id, getter);
|
||||
}
|
||||
|
|
@ -2248,8 +2275,8 @@ void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPo
|
|||
ImU32 tint_col32 = ImGui::ColorConvertFloat4ToU32(tint_col);
|
||||
GetCurrentItem()->Color = tint_col32;
|
||||
ImDrawList& DrawList = *GetPlotDrawList();
|
||||
ImVec2 p1 = PlotToPixels(bmin.x, bmax.y);
|
||||
ImVec2 p2 = PlotToPixels(bmax.x, bmin.y);
|
||||
ImVec2 p1 = PlotToPixels(bmin.x, bmax.y,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
ImVec2 p2 = PlotToPixels(bmax.x, bmin.y,IMPLOT_AUTO,IMPLOT_AUTO);
|
||||
PushPlotClipRect();
|
||||
DrawList.AddImage(user_texture_id, p1, p2, uv0, uv1, tint_col32);
|
||||
PopPlotClipRect();
|
||||
|
|
@ -2264,16 +2291,27 @@ void PlotImage(const char* label_id, ImTextureID user_texture_id, const ImPlotPo
|
|||
// double
|
||||
void PlotText(const char* text, double x, double y, bool vertical, const ImVec2& pixel_offset) {
|
||||
IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != NULL, "PlotText() needs to be called between BeginPlot() and EndPlot()!");
|
||||
SetupLock();
|
||||
ImDrawList & DrawList = *GetPlotDrawList();
|
||||
PushPlotClipRect();
|
||||
ImU32 colTxt = GetStyleColorU32(ImPlotCol_InlayText);
|
||||
if (vertical) {
|
||||
ImVec2 ctr = CalcTextSizeVertical(text) * 0.5f;
|
||||
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) + ImVec2(-ctr.x, ctr.y) + pixel_offset;
|
||||
ImVec2 siz = CalcTextSizeVertical(text) * 0.5f;
|
||||
ImVec2 ctr = siz * 0.5f;
|
||||
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y),IMPLOT_AUTO,IMPLOT_AUTO) + ImVec2(-ctr.x, ctr.y) + pixel_offset;
|
||||
if (FitThisFrame()) {
|
||||
FitPoint(PixelsToPlot(pos));
|
||||
FitPoint(PixelsToPlot(pos.x + siz.x, pos.y - siz.y));
|
||||
}
|
||||
AddTextVertical(&DrawList, pos, colTxt, text);
|
||||
}
|
||||
else {
|
||||
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y)) - ImGui::CalcTextSize(text) * 0.5f + pixel_offset;
|
||||
ImVec2 siz = ImGui::CalcTextSize(text);
|
||||
ImVec2 pos = PlotToPixels(ImPlotPoint(x,y),IMPLOT_AUTO,IMPLOT_AUTO) - siz * 0.5f + pixel_offset;
|
||||
if (FitThisFrame()) {
|
||||
FitPoint(PixelsToPlot(pos));
|
||||
FitPoint(PixelsToPlot(pos+siz));
|
||||
}
|
||||
DrawList.AddText(pos, colTxt, text);
|
||||
}
|
||||
PopPlotClipRect();
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user