Start from a clean slate

1 files changed, 0 insertions, 1143 deletions

diff --git a/3rdparty/implot/implot.h b/3rdparty/implot/implot.h
deleted file mode 100644
index 8226eda..0000000
--- a/3rdparty/implot/implot.h
+++ /dev/null
@@ -1,1143 +0,0 @@
-// MIT License
-
-// Copyright (c) 2021 Evan Pezent
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-// ImPlot 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"
-
-//-----------------------------------------------------------------------------
-// [SECTION] Macros and Defines
-//-----------------------------------------------------------------------------
-
-// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
-// Using ImPlot via a shared library is not recommended, because we don't guarantee
-// backward nor forward ABI compatibility and also function call overhead. If you
-// do use ImPlot as a DLL, be sure to call SetImGuiContext (see Miscellanous section).
-#ifndef IMPLOT_API
-#define IMPLOT_API
-#endif
-
-// 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)
-// Macro for templated plotting functions; keeps header clean.
-#define IMPLOT_TMP template <typename T> IMPLOT_API
-
-//-----------------------------------------------------------------------------
-// [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 ImPlotBarGroupsFlags; // -> ImPlotBarGroupsFlags_
-
-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 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_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_NoFrame       = 1 << 7,  // the ImGui frame will not be rendered
-    ImPlotFlags_Equal         = 1 << 8,  // x and y axes pairs will be constrained to have the same units/pixel
-    ImPlotFlags_Crosshairs    = 1 << 9,  // the default mouse cursor will be replaced with a crosshair when hovered
-    ImPlotFlags_AntiAliased   = 1 << 10, // plot items will be software anti-aliased (not recommended for high density plots, prefer MSAA)
-    ImPlotFlags_CanvasOnly    = ImPlotFlags_NoTitle | ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect | ImPlotFlags_NoMouseText
-};
-
-// 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_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_AuxDefault    = ImPlotAxisFlags_NoGridLines | ImPlotAxisFlags_Opposite
-};
-
-// Options for subplots (see BeginSubplot).
-enum ImPlotSubplotFlags_ {
-    ImPlotSubplotFlags_None        = 0,       // default
-    ImPlotSubplotFlags_NoTitle     = 1 << 0,  // the subplot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MySubplot")
-    ImPlotSubplotFlags_NoLegend    = 1 << 1,  // the legend will not be displayed (only applicable if ImPlotSubplotFlags_ShareItems is enabled)
-    ImPlotSubplotFlags_NoMenus     = 1 << 2,  // the user will not be able to open context menus with right-click
-    ImPlotSubplotFlags_NoResize    = 1 << 3,  // resize splitters between subplot cells will be not be provided
-    ImPlotSubplotFlags_NoAlign     = 1 << 4,  // subplot edges will not be aligned vertically or horizontally
-    ImPlotSubplotFlags_ShareItems  = 1 << 5,  // items across all subplots will be shared and rendered into a single legend entry
-    ImPlotSubplotFlags_LinkRows    = 1 << 6,  // link the y-axis limits of all plots in each row (does not apply to auxiliary axes)
-    ImPlotSubplotFlags_LinkCols    = 1 << 7,  // link the x-axis limits of all plots in each column (does not apply to auxiliary axes)
-    ImPlotSubplotFlags_LinkAllX    = 1 << 8,  // link the x-axis limits in every plot in the subplot (does not apply to auxiliary axes)
-    ImPlotSubplotFlags_LinkAllY    = 1 << 9,  // link the y-axis limits in every plot in the subplot (does not apply to auxiliary axes)
-    ImPlotSubplotFlags_ColMajor    = 1 << 10  // subplots are added in column major order instead of the default row major order
-};
-
-// 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
-};
-
-// Flags for ImPlot::PlotBarGroups
-enum ImPlotBarGroupsFlags_ {
-    ImPlotBarGroupsFlags_None     = 0,      // default
-    ImPlotBarGroupsFlags_Stacked  = 1 << 0, // items in a group will be stacked on top of each other
-};
-
-// 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
-    ImPlotCol_Line,          // plot line/outline color (defaults to next unused color in current colormap)
-    ImPlotCol_Fill,          // plot fill color for bars (defaults to the current line color)
-    ImPlotCol_MarkerOutline, // marker outline color (defaults to the current line color)
-    ImPlotCol_MarkerFill,    // marker fill color (defaults to the current line color)
-    ImPlotCol_ErrorBar,      // error bar color (defaults to ImGuiCol_Text)
-    // plot styling colors
-    ImPlotCol_FrameBg,       // plot frame background color (defaults to ImGuiCol_FrameBg)
-    ImPlotCol_PlotBg,        // plot area background color (defaults to ImGuiCol_WindowBg)
-    ImPlotCol_PlotBorder,    // plot area border color (defaults to ImGuiCol_Border)
-    ImPlotCol_LegendBg,      // legend background color (defaults to ImGuiCol_PopupBg)
-    ImPlotCol_LegendBorder,  // legend border color (defaults to ImPlotCol_PlotBorder)
-    ImPlotCol_LegendText,    // legend text color (defaults to ImPlotCol_InlayText)
-    ImPlotCol_TitleText,     // plot title text color (defaults to ImGuiCol_Text)
-    ImPlotCol_InlayText,     // color of text appearing inside of plots (defaults to ImGuiCol_Text)
-    ImPlotCol_AxisText,      // axis label and tick lables color (defaults to ImGuiCol_Text)
-    ImPlotCol_AxisGrid,      // axis grid color (defaults to 25% ImPlotCol_AxisText)
-    ImPlotCol_AxisTick,      // axis tick color (defaults to AxisGrid)
-    ImPlotCol_AxisBg,        // background color of axis hover region (defaults to transparent)
-    ImPlotCol_AxisBgHovered, // axis hover color (defaults to ImGuiCol_ButtonHovered)
-    ImPlotCol_AxisBgActive,  // axis active color (defaults to ImGuiCol_ButtonActive)
-    ImPlotCol_Selection,     // box-selection color (defaults to yellow)
-    ImPlotCol_Crosshairs,    // crosshairs color (defaults to ImPlotCol_PlotBorder)
-    ImPlotCol_COUNT
-};
-
-// Plot styling variables.
-enum ImPlotStyleVar_ {
-    // item styling variables
-    ImPlotStyleVar_LineWeight,         // float,  plot item line weight in pixels
-    ImPlotStyleVar_Marker,             // int,    marker specification
-    ImPlotStyleVar_MarkerSize,         // float,  marker size in pixels (roughly the marker's "radius")
-    ImPlotStyleVar_MarkerWeight,       // float,  plot outline weight of markers in pixels
-    ImPlotStyleVar_FillAlpha,          // float,  alpha modifier applied to all plot item fills
-    ImPlotStyleVar_ErrorBarSize,       // float,  error bar whisker width in pixels
-    ImPlotStyleVar_ErrorBarWeight,     // float,  error bar whisker weight in pixels
-    ImPlotStyleVar_DigitalBitHeight,   // float,  digital channels bit height (at 1) in pixels
-    ImPlotStyleVar_DigitalBitGap,      // float,  digital channels bit padding gap in pixels
-    // plot styling variables
-    ImPlotStyleVar_PlotBorderSize,     // float,  thickness of border around plot area
-    ImPlotStyleVar_MinorAlpha,         // float,  alpha multiplier applied to minor axis grid lines
-    ImPlotStyleVar_MajorTickLen,       // ImVec2, major tick lengths for X and Y axes
-    ImPlotStyleVar_MinorTickLen,       // ImVec2, minor tick lengths for X and Y axes
-    ImPlotStyleVar_MajorTickSize,      // ImVec2, line thickness of major ticks
-    ImPlotStyleVar_MinorTickSize,      // ImVec2, line thickness of minor ticks
-    ImPlotStyleVar_MajorGridSize,      // ImVec2, line thickness of major grid lines
-    ImPlotStyleVar_MinorGridSize,      // ImVec2, line thickness of minor grid lines
-    ImPlotStyleVar_PlotPadding,        // ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
-    ImPlotStyleVar_LabelPadding,       // ImVec2, padding between axes labels, tick labels, and plot edge
-    ImPlotStyleVar_LegendPadding,      // ImVec2, legend padding from plot edges
-    ImPlotStyleVar_LegendInnerPadding, // ImVec2, legend inner padding from legend edges
-    ImPlotStyleVar_LegendSpacing,      // ImVec2, spacing between legend entries
-    ImPlotStyleVar_MousePosPadding,    // ImVec2, padding between plot edge and interior info text
-    ImPlotStyleVar_AnnotationPadding,  // ImVec2, text padding around annotation labels
-    ImPlotStyleVar_FitPadding,         // ImVec2, additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
-    ImPlotStyleVar_PlotDefaultSize,    // ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot
-    ImPlotStyleVar_PlotMinSize,        // ImVec2, minimum size plot frame can be when shrunk
-    ImPlotStyleVar_COUNT
-};
-
-// Marker specifications.
-enum ImPlotMarker_ {
-    ImPlotMarker_None = -1, // no marker
-    ImPlotMarker_Circle,    // a circle marker
-    ImPlotMarker_Square,    // a square maker
-    ImPlotMarker_Diamond,   // a diamond marker
-    ImPlotMarker_Up,        // an upward-pointing triangle marker
-    ImPlotMarker_Down,      // an downward-pointing triangle marker
-    ImPlotMarker_Left,      // an leftward-pointing triangle marker
-    ImPlotMarker_Right,     // an rightward-pointing triangle marker
-    ImPlotMarker_Cross,     // a cross marker (not fillable)
-    ImPlotMarker_Plus,      // a plus marker (not fillable)
-    ImPlotMarker_Asterisk,  // a asterisk marker (not fillable)
-    ImPlotMarker_COUNT
-};
-
-// Built-in colormaps
-enum ImPlotColormap_ {
-    ImPlotColormap_Deep     = 0,   // a.k.a. seaborn deep             (qual=true,  n=10) (default)
-    ImPlotColormap_Dark     = 1,   // a.k.a. matplotlib "Set1"        (qual=true,  n=9 )
-    ImPlotColormap_Pastel   = 2,   // a.k.a. matplotlib "Pastel1"     (qual=true,  n=9 )
-    ImPlotColormap_Paired   = 3,   // a.k.a. matplotlib "Paired"      (qual=true,  n=12)
-    ImPlotColormap_Viridis  = 4,   // a.k.a. matplotlib "viridis"     (qual=false, n=11)
-    ImPlotColormap_Plasma   = 5,   // a.k.a. matplotlib "plasma"      (qual=false, n=11)
-    ImPlotColormap_Hot      = 6,   // a.k.a. matplotlib/MATLAB "hot"  (qual=false, n=11)
-    ImPlotColormap_Cool     = 7,   // a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11)
-    ImPlotColormap_Pink     = 8,   // a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11)
-    ImPlotColormap_Jet      = 9,   // a.k.a. MATLAB "jet"             (qual=false, n=11)
-    ImPlotColormap_Twilight = 10,  // a.k.a. matplotlib "twilight"    (qual=false, n=11)
-    ImPlotColormap_RdBu     = 11,  // red/blue, Color Brewer          (qual=false, n=11)
-    ImPlotColormap_BrBG     = 12,  // brown/blue-green, Color Brewer  (qual=false, n=11)
-    ImPlotColormap_PiYG     = 13,  // pink/yellow-green, Color Brewer (qual=false, n=11)
-    ImPlotColormap_Spectral = 14,  // color spectrum, Color Brewer    (qual=false, n=11)
-    ImPlotColormap_Greys    = 15,  // white/black                     (qual=false, n=2 )
-};
-
-// Used to position items on a plot (e.g. legends, labels, etc.)
-enum ImPlotLocation_ {
-    ImPlotLocation_Center    = 0,                                          // center-center
-    ImPlotLocation_North     = 1 << 0,                                     // top-center
-    ImPlotLocation_South     = 1 << 1,                                     // bottom-center
-    ImPlotLocation_West      = 1 << 2,                                     // center-left
-    ImPlotLocation_East      = 1 << 3,                                     // center-right
-    ImPlotLocation_NorthWest = ImPlotLocation_North | ImPlotLocation_West, // top-left
-    ImPlotLocation_NorthEast = ImPlotLocation_North | ImPlotLocation_East, // top-right
-    ImPlotLocation_SouthWest = ImPlotLocation_South | ImPlotLocation_West, // bottom-left
-    ImPlotLocation_SouthEast = ImPlotLocation_South | ImPlotLocation_East  // bottom-right
-};
-
-// Enums for different automatic histogram binning methods (k = bin count or w = bin width)
-enum ImPlotBin_ {
-    ImPlotBin_Sqrt    = -1, // k = sqrt(n)
-    ImPlotBin_Sturges = -2, // k = 1 + log2(n)
-    ImPlotBin_Rice    = -3, // k = 2 * cbrt(n)
-    ImPlotBin_Scott   = -4, // w = 3.49 * sigma / cbrt(n)
-};
-
-// Double precision version of ImVec2 used by ImPlot. Extensible by end users.
-struct ImPlotPoint {
-    double x, y;
-    ImPlotPoint()                         { x = y = 0.0;      }
-    ImPlotPoint(double _x, double _y)     { x = _x; y = _y;   }
-    ImPlotPoint(const ImVec2& p)          { x = p.x; y = p.y; }
-    double  operator[] (size_t idx) const { return (&x)[idx]; }
-    double& operator[] (size_t idx)       { return (&x)[idx]; }
-#ifdef IMPLOT_POINT_CLASS_EXTRA
-    IMPLOT_POINT_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h
-                                 // to convert back and forth between your math types and ImPlotPoint.
-#endif
-};
-
-// 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;                                         }
-    double Clamp(double value) const      { return (value < Min) ? Min : (value > Max) ? Max : value; }
-};
-
-// Combination of two range limits for X and Y axes. Also an AABB defined by Min()/Max().
-struct ImPlotRect {
-    ImPlotRange X, Y;
-    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);                             }
-};
-
-// Plot style structure
-struct ImPlotStyle {
-    // item styling variables
-    float   LineWeight;              // = 1,      item line weight in pixels
-    int     Marker;                  // = ImPlotMarker_None, marker specification
-    float   MarkerSize;              // = 4,      marker size in pixels (roughly the marker's "radius")
-    float   MarkerWeight;            // = 1,      outline weight of markers in pixels
-    float   FillAlpha;               // = 1,      alpha modifier applied to plot fills
-    float   ErrorBarSize;            // = 5,      error bar whisker width in pixels
-    float   ErrorBarWeight;          // = 1.5,    error bar whisker weight in pixels
-    float   DigitalBitHeight;        // = 8,      digital channels bit height (at y = 1.0f) in pixels
-    float   DigitalBitGap;           // = 4,      digital channels bit padding gap in pixels
-    // plot styling variables
-    float   PlotBorderSize;          // = 1,      line thickness of border around plot area
-    float   MinorAlpha;              // = 0.25    alpha multiplier applied to minor axis grid lines
-    ImVec2  MajorTickLen;            // = 10,10   major tick lengths for X and Y axes
-    ImVec2  MinorTickLen;            // = 5,5     minor tick lengths for X and Y axes
-    ImVec2  MajorTickSize;           // = 1,1     line thickness of major ticks
-    ImVec2  MinorTickSize;           // = 1,1     line thickness of minor ticks
-    ImVec2  MajorGridSize;           // = 1,1     line thickness of major grid lines
-    ImVec2  MinorGridSize;           // = 1,1     line thickness of minor grid lines
-    ImVec2  PlotPadding;             // = 10,10   padding between widget frame and plot area, labels, or outside legends (i.e. main padding)
-    ImVec2  LabelPadding;            // = 5,5     padding between axes labels, tick labels, and plot edge
-    ImVec2  LegendPadding;           // = 10,10   legend padding from plot edges
-    ImVec2  LegendInnerPadding;      // = 5,5     legend inner padding from legend edges
-    ImVec2  LegendSpacing;           // = 5,0     spacing between legend entries
-    ImVec2  MousePosPadding;         // = 10,10   padding between plot edge and interior mouse location text
-    ImVec2  AnnotationPadding;       // = 2,2     text padding around annotation labels
-    ImVec2  FitPadding;              // = 0,0     additional fit padding as a percentage of the fit extents (e.g. ImVec2(0.1f,0.1f) adds 10% to the fit extents of X and Y)
-    ImVec2  PlotDefaultSize;         // = 400,300 default size used when ImVec2(0,0) is passed to BeginPlot
-    ImVec2  PlotMinSize;             // = 200,150 minimum size plot frame can be when shrunk
-    // style colors
-    ImVec4  Colors[ImPlotCol_COUNT]; // Array of styling colors. Indexable with ImPlotCol_ enums.
-    // colormap
-    ImPlotColormap Colormap;         // The current colormap. Set this to either an ImPlotColormap_ enum or an index returned by AddColormap.
-    // settings/flags
-    bool    AntiAliasedLines;        // = false,  enable global anti-aliasing on plot lines (overrides ImPlotFlags_AntiAliased)
-    bool    UseLocalTime;            // = false,  axis labels will be formatted for your timezone when ImPlotAxisFlag_Time is enabled
-    bool    UseISO8601;              // = false,  dates will be formatted according to ISO 8601 where applicable (e.g. YYYY-MM-DD, YYYY-MM, --MM-DD, etc.)
-    bool    Use24HourClock;          // = false,  times will be formatted using a 24 hour clock
-    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();
-};
-
-//-----------------------------------------------------------------------------
-// [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 {
-
-//-----------------------------------------------------------------------------
-// [SECTION] Contexts
-//-----------------------------------------------------------------------------
-
-// Creates a new ImPlot context. Call this after ImGui::CreateContext.
-IMPLOT_API ImPlotContext* CreateContext();
-// Destroys an ImPlot context. Call this before ImGui::DestroyContext. NULL = destroy current context.
-IMPLOT_API void DestroyContext(ImPlotContext* ctx = NULL);
-// Returns the current ImPlot context. NULL if no context has ben set.
-IMPLOT_API ImPlotContext* GetCurrentContext();
-// Sets the current ImPlot context.
-IMPLOT_API void SetCurrentContext(ImPlotContext* ctx);
-
-// Sets the current **ImGui** context. This is ONLY necessary if you are compiling
-// ImPlot as a DLL (not recommended) separate from your ImGui compilation. It
-// sets the global variable GImGui, which is not shared across DLL boundaries.
-// See GImGui documentation in imgui.cpp for more details.
-IMPLOT_API void SetImGuiContext(ImGuiContext* ctx);
-
-//-----------------------------------------------------------------------------
-// [SECTION] Begin/End Plot
-//-----------------------------------------------------------------------------
-
-// Starts a 2D plotting context. If this function returns true, EndPlot() MUST
-// be called! You are encouraged to use the following convention:
-//
-// if (BeginPlot(...)) {
-//     PlotLine(...);
-//     ...
-//     EndPlot();
-// }
-//
-// Important notes:
-//
-// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
-//   collisions or don't want to display a title in the plot, use double hashes
-//   (e.g. "MyPlot##HiddenIdText" or "##NoTitle").
-// - #size is the **frame** size of the plot widget, not the plot area. The default
-//   size of plots (i.e. when ImVec2(0,0)) can be modified in your ImPlotStyle.
-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();
-
-//-----------------------------------------------------------------------------
-// [SECTION] Begin/End Subplots
-//-----------------------------------------------------------------------------
-
-// Starts a subdivided plotting context. If the function returns true,
-// EndSubplots() MUST be called! Call BeginPlot/EndPlot AT MOST [rows*cols]
-// times in  between the begining and end of the subplot context. Plots are
-// added in row major order.
-//
-// Example:
-//
-// if (BeginSubplots("My Subplot",2,3,ImVec2(800,400)) {
-//     for (int i = 0; i < 6; ++i) {
-//         if (BeginPlot(...)) {
-//             ImPlot::PlotLine(...);
-//             ...
-//             EndPlot();
-//         }
-//     }
-//     EndSubplots();
-// }
-//
-// Produces:
-//
-// [0] | [1] | [2]
-// ----|-----|----
-// [3] | [4] | [5]
-//
-// Important notes:
-//
-// - #title_id must be unique to the current ImGui ID scope. If you need to avoid ID
-//   collisions or don't want to display a title in the plot, use double hashes
-//   (e.g. "MySubplot##HiddenIdText" or "##NoTitle").
-// - #rows and #cols must be greater than 0.
-// - #size is the size of the entire grid of subplots, not the individual plots
-// - #row_ratios and #col_ratios must have AT LEAST #rows and #cols elements,
-//   respectively. These are the sizes of the rows and columns expressed in ratios.
-//   If the user adjusts the dimensions, the arrays are updated with new ratios.
-//
-// Important notes regarding BeginPlot from inside of BeginSubplots:
-//
-// - The #title_id parameter of _BeginPlot_ (see above) does NOT have to be
-//   unique when called inside of a subplot context. Subplot IDs are hashed
-//   for your convenience so you don't have call PushID or generate unique title
-//   strings. Simply pass an empty string to BeginPlot unless you want to title
-//   each subplot.
-// - The #size parameter of _BeginPlot_ (see above) is ignored when inside of a
-//   subplot context. The actual size of the subplot will be based on the
-//   #size value you pass to _BeginSubplots_ and #row/#col_ratios if provided.
-
-IMPLOT_API bool BeginSubplots(const char* title_id,
-                             int rows,
-                             int cols,
-                             const ImVec2& size,
-                             ImPlotSubplotFlags flags = ImPlotSubplotFlags_None,
-                             float* row_ratios        = NULL,
-                             float* col_ratios        = NULL);
-
-// Only call EndSubplots() if BeginSubplots() returns true! Typically called at the end
-// of an if statement conditioned on BeginSublots(). See example above.
-IMPLOT_API void EndSubplots();
-
-//-----------------------------------------------------------------------------
-// [SECTION] Setup
-//-----------------------------------------------------------------------------
-
-// The following API allows you to setup and customize various aspects of the
-// current plot. The functions should be called immediately after BeginPlot
-// and before any other API calls. Typical usage is as follows:
-
-// if (BeginPlot(...)) {                     1) begin a new plot
-//     SetupAxis(ImAxis_X1, "My X-Axis");    2) make Setup calls
-//     SetupAxis(ImAxis_Y1, "My Y-Axis");
-//     SetupLegend(ImPlotLocation_North);
-//     ...
-//     SetupFinish();                        3) [optional] explicitly finish setup
-//     PlotLine(...);                        4) plot items
-//     ...
-//     EndPlot();                            5) end the plot
-// }
-//
-// Important notes:
-//
-// - Always call Setup code at the top of your BeginPlot conditional statement.
-// - Setup is locked once you start plotting or explicitly call SetupFinish.
-//   Do NOT call Setup code after you begin plotting or after you make
-//   any non-Setup API calls (e.g. utils like PlotToPixels also lock Setup)
-// - Calling SetupFinish is OPTIONAL, but probably good practice. If you do not
-//   call it yourself, then the first subsequent plotting or utility function will
-//   call it for you.
-
-// Enables an axis or sets the label and/or flags for an existing axis. Leave #label = 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 templated functions are explicitly instantiated in implot_items.cpp.
-// They are not intended to be used generically with custom types. You will get
-// a linker error if you try! All functions support the following scalar types:
-//
-// float, double, ImS8, ImU8, ImS16, ImU16, ImS32, ImU32, ImS64, ImU64
-//
-//
-// If you need to plot custom or non-homogenous data you have a few options:
-//
-// 1. If your data is a simple struct/class (e.g. Vector2f), you can use striding.
-//    This is the most performant option if applicable.
-//
-//    struct Vector2f { float X, Y; };
-//    ...
-//    Vector2f data[42];
-//    ImPlot::PlotLine("line", &data[0].x, &data[0].y, 42, 0, sizeof(Vector2f)); // or sizeof(float)*2
-//
-// 2. Write a custom getter C function or C++ lambda and pass it and optionally your data to
-//    an ImPlot function post-fixed with a G (e.g. PlotScatterG). This has a slight performance
-//    cost, but probably not enough to worry about unless your data is very large. Examples:
-//
-//    ImPlotPoint MyDataGetter(void* data, int idx) {
-//        MyData* my_data = (MyData*)data;
-//        ImPlotPoint p;
-//        p.x = my_data->GetTime(idx);
-//        p.y = my_data->GetValue(idx);
-//        return p
-//    }
-//    ...
-//    auto my_lambda = [](void*, int idx) {
-//        double t = idx / 999.0;
-//        return ImPlotPoint(t, 0.5+0.5*std::sin(2*PI*10*t));
-//    };
-//    ...
-//    if (ImPlot::BeginPlot("MyPlot")) {
-//        MyData my_data;
-//        ImPlot::PlotScatterG("scatter", MyDataGetter, &my_data, my_data.Size());
-//        ImPlot::PlotLineG("line", my_lambda, nullptr, 1000);
-//        ImPlot::EndPlot();
-//    }
-//
-// NB: All types are converted to double before plotting. You may lose information
-// if you try plotting extremely large 64-bit integral types. Proceed with caution!
-
-// Plots a standard 2D line plot.
-IMPLOT_TMP void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotLine(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotLineG(const char* label_id, ImPlotGetter getter, void* data, int count);
-
-// Plots a standard 2D scatter plot. Default marker is ImPlotMarker_Circle.
-IMPLOT_TMP void PlotScatter(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotScatterG(const char* label_id, ImPlotGetter getter, void* data, int count);
-
-// Plots a a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i].
-IMPLOT_TMP void PlotStairs(const char* label_id, const T* values, int count, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotStairs(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotStairsG(const char* label_id, ImPlotGetter getter, void* data, int count);
-
-// Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yref to +/-INFINITY for infinite fill extents.
-IMPLOT_TMP void PlotShaded(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double yref=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T* ys2, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotShadedG(const char* label_id, ImPlotGetter getter1, void* data1, ImPlotGetter getter2, void* data2, int count);
-
-// Plots a vertical bar graph. #bar_width and #x0 are in X units.
-IMPLOT_TMP void PlotBars(const char* label_id, const T* values, int count, double bar_width=0.67, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotBars(const char* label_id, const T* xs, const T* ys, int count, double bar_width, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotBarsG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_width);
-
-// Plots a horizontal bar graph. #bar_height and #y0 are in Y units.
-IMPLOT_TMP void PlotBarsH(const char* label_id, const T* values, int count, double bar_height=0.67, double y0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotBarsH(const char* label_id, const T* xs, const T* ys, int count, double bar_height, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotBarsHG(const char* label_id, ImPlotGetter getter, void* data, int count, double bar_height);
-
-// Plots a group of vertical bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
-IMPLOT_TMP void PlotBarGroups(const char* const label_ids[], const T* values, int item_count, int group_count, double group_width=0.67, double x0=0, ImPlotBarGroupsFlags flags=ImPlotBarGroupsFlags_None);
-
-// Plots a group of horizontal bars. #values is a row-major matrix with #item_count rows and #group_count cols. #label_ids should have #item_count elements.
-IMPLOT_TMP void PlotBarGroupsH(const char* const label_ids[], const T* values, int item_count, int group_count, double group_height=0.67, double y0=0, ImPlotBarGroupsFlags flags=ImPlotBarGroupsFlags_None);
-
-// Plots vertical error bar. The label_id should be the same as the label_id of the associated line or bar plot.
-IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
-
-// Plots horizontal error bars. The label_id should be the same as the label_id of the associated line or bar plot.
-IMPLOT_TMP void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset=0, int stride=sizeof(T));
-
-/// Plots vertical stems.
-IMPLOT_TMP void PlotStems(const char* label_id, const T* values, int count, double yref=0, double xscale=1, double x0=0, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double yref=0, int offset=0, int stride=sizeof(T));
-
-/// Plots infinite vertical or horizontal lines (e.g. for references or asymptotes).
-IMPLOT_TMP void PlotVLines(const char* label_id, const T* xs, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_TMP void PlotHLines(const char* label_id, const T* ys, int count, int offset=0, int stride=sizeof(T));
-
-// Plots a pie chart. If the sum of values > 1 or normalize is true, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels.
-IMPLOT_TMP void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize=false, const char* label_fmt="%.1f", double angle0=90);
-
-// Plots a 2D heatmap chart. Values are expected to be in row-major order. Leave #scale_min and scale_max both at 0 for automatic color scaling, or set them to a predefined range. #label_fmt can be set to NULL for no labels.
-IMPLOT_TMP void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min=0, double scale_max=0, const char* label_fmt="%.1f", const ImPlotPoint& bounds_min=ImPlotPoint(0,0), const ImPlotPoint& bounds_max=ImPlotPoint(1,1));
-
-// Plots a horizontal histogram. #bins can be a positive integer or an ImPlotBin_ method. If #cumulative is true, each bin contains its count plus the counts of all previous bins.
-// If #density is true, the PDF is visualized. If both are true, the CDF is visualized. If #range is left unspecified, the min/max of #values will be used as the range.
-// If #range is specified, outlier values outside of the range are not binned. However, outliers still count toward normalizing and cumulative counts unless #outliers is false. The largest bin count or density is returned.
-IMPLOT_TMP double PlotHistogram(const char* label_id, const T* values, int count, int bins=ImPlotBin_Sturges, bool cumulative=false, bool density=false, ImPlotRange range=ImPlotRange(), bool outliers=true, double bar_scale=1.0);
-
-// Plots two dimensional, bivariate histogram as a heatmap. #x_bins and #y_bins can be a positive integer or an ImPlotBin. If #density is true, the PDF is visualized.
-// If #bounds is left unspecified, the min/max of #xs an #ys will be used as the ranges. If #bounds is specified, outlier values outside of range are not binned.
-// However, outliers still count toward the normalizing count for density plots unless #outliers is false. The largest bin count or density is returned.
-IMPLOT_TMP double PlotHistogram2D(const char* label_id, const T* xs, const T* ys, int count, int x_bins=ImPlotBin_Sturges, int y_bins=ImPlotBin_Sturges, bool density=false, ImPlotRect range=ImPlotRect(), bool outliers=true);
-
-// Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot.
-IMPLOT_TMP void PlotDigital(const char* label_id, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T));
-IMPLOT_API void PlotDigitalG(const char* label_id, ImPlotGetter getter, void* data, int count);
-
-// 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));
-
-// Plots a centered text label at point x,y with an optional pixel offset. Text color can be changed with ImPlot::PushStyleColor(ImPlotCol_InlayText, ...).
-IMPLOT_API void PlotText(const char* text, double x, double y, bool vertical=false, const ImVec2& pix_offset=ImVec2(0,0));
-
-// Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line)
-IMPLOT_API void PlotDummy(const char* label_id);
-
-//-----------------------------------------------------------------------------
-// [SECTION] Plot Tools
-//-----------------------------------------------------------------------------
-
-// The following can be used to render interactive elements and/or annotations.
-// Like the item plotting functions above, they apply to the current x and y
-// axes, which can be changed with `SetAxis/SetAxes`.
-
-// 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);
-
-// 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);
-
-// 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);
-
-// 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);
-
-//-----------------------------------------------------------------------------
-// [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);
-
-// 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 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. 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();
-
-// 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. #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();
-
-//-----------------------------------------------------------------------------
-// [SECTION] Legend Utils
-//-----------------------------------------------------------------------------
-
-// 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);
-
-//-----------------------------------------------------------------------------
-// [SECTION] Drag and Drop
-//-----------------------------------------------------------------------------
-
-// Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget!
-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 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).
-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. 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();
-
-//-----------------------------------------------------------------------------
-// [SECTION] Styling
-//-----------------------------------------------------------------------------
-
-// Styling colors in ImPlot works similarly to styling colors in ImGui, but
-// with one important difference. Like ImGui, all style colors are stored in an
-// indexable array in ImPlotStyle. You can permanently modify these values through
-// GetStyle().Colors, or temporarily modify them with Push/Pop functions below.
-// However, by default all style colors in ImPlot default to a special color
-// IMPLOT_AUTO_COL. The behavior of this color depends upon the style color to
-// which it as applied:
-//
-//     1) For style colors associated with plot items (e.g. ImPlotCol_Line),
-//        IMPLOT_AUTO_COL tells ImPlot to color the item with the next unused
-//        color in the current colormap. Thus, every item will have a different
-//        color up to the number of colors in the colormap, at which point the
-//        colormap will roll over. For most use cases, you should not need to
-//        set these style colors to anything but IMPLOT_COL_AUTO; you are
-//        probably better off changing the current colormap. However, if you
-//        need to explicitly color a particular item you may either Push/Pop
-//        the style color around the item in question, or use the SetNextXXXStyle
-//        API below. If you permanently set one of these style colors to a specific
-//        color, or forget to call Pop, then all subsequent items will be styled
-//        with the color you set.
-//
-//     2) For style colors associated with plot styling (e.g. ImPlotCol_PlotBg),
-//        IMPLOT_AUTO_COL tells ImPlot to set that color from color data in your
-//        **ImGuiStyle**. The ImGuiCol_ that these style colors default to are
-//        detailed above, and in general have been mapped to produce plots visually
-//        consistent with your current ImGui style. Of course, you are free to
-//        manually set these colors to whatever you like, and further can Push/Pop
-//        them around individual plots for plot-specific styling (e.g. coloring axes).
-
-// Provides access to plot style structure for permanant modifications to colors, sizes, etc.
-IMPLOT_API ImPlotStyle& GetStyle();
-
-// Style plot colors for current ImGui style (default).
-IMPLOT_API void StyleColorsAuto(ImPlotStyle* dst = NULL);
-// Style plot colors for ImGui "Classic".
-IMPLOT_API void StyleColorsClassic(ImPlotStyle* dst = NULL);
-// Style plot colors for ImGui "Dark".
-IMPLOT_API void StyleColorsDark(ImPlotStyle* dst = NULL);
-// Style plot colors for ImGui "Light".
-IMPLOT_API void StyleColorsLight(ImPlotStyle* dst = NULL);
-
-// Use PushStyleX to temporarily modify your ImPlotStyle. The modification
-// will last until the matching call to PopStyleX. You MUST call a pop for
-// every push, otherwise you will leak memory! This behaves just like ImGui.
-
-// Temporarily modify a style color. Don't forget to call PopStyleColor!
-IMPLOT_API void PushStyleColor(ImPlotCol idx, ImU32 col);
-IMPLOT_API void PushStyleColor(ImPlotCol idx, const ImVec4& col);
-// Undo temporary style color modification(s). Undo multiple pushes at once by increasing count.
-IMPLOT_API void PopStyleColor(int count = 1);
-
-// Temporarily modify a style variable of float type. Don't forget to call PopStyleVar!
-IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, float val);
-// Temporarily modify a style variable of int type. Don't forget to call PopStyleVar!
-IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, int val);
-// Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar!
-IMPLOT_API void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val);
-// Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count.
-IMPLOT_API void PopStyleVar(int count = 1);
-
-// The following can be used to modify the style of the next plot item ONLY. They do
-// NOT require calls to PopStyleX. Leave style attributes you don't want modified to
-// IMPLOT_AUTO or IMPLOT_AUTO_COL. Automatic styles will be deduced from the current
-// values in your ImPlotStyle or from Colormap data.
-
-// Set the line color and weight for the next item only.
-IMPLOT_API void SetNextLineStyle(const ImVec4& col = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO);
-// Set the fill color for the next item only.
-IMPLOT_API void SetNextFillStyle(const ImVec4& col = IMPLOT_AUTO_COL, float alpha_mod = IMPLOT_AUTO);
-// Set the marker style for the next item only.
-IMPLOT_API void SetNextMarkerStyle(ImPlotMarker marker = IMPLOT_AUTO, float size = IMPLOT_AUTO, const ImVec4& fill = IMPLOT_AUTO_COL, float weight = IMPLOT_AUTO, const ImVec4& outline = IMPLOT_AUTO_COL);
-// Set the error bar style for the next item only.
-IMPLOT_API void SetNextErrorBarStyle(const ImVec4& col = IMPLOT_AUTO_COL, float size = IMPLOT_AUTO, float weight = IMPLOT_AUTO);
-
-// Gets the last item primary color (i.e. its legend icon color)
-IMPLOT_API ImVec4 GetLastItemColor();
-
-// Returns the null terminated string name for an ImPlotCol.
-IMPLOT_API const char* GetStyleColorName(ImPlotCol idx);
-// Returns the null terminated string name for an ImPlotMarker.
-IMPLOT_API const char* GetMarkerName(ImPlotMarker idx);
-
-//-----------------------------------------------------------------------------
-// [SECTION] Colormaps
-//-----------------------------------------------------------------------------
-
-// Item styling is based on colormaps when the relevant ImPlotCol_XXX is set to
-// IMPLOT_AUTO_COL (default). Several built-in colormaps are available. You can
-// add and then push/pop your own colormaps as well. To permanently set a colormap,
-// modify the Colormap index member of your ImPlotStyle.
-
-// Colormap data will be ignored and a custom color will be used if you have done one of the following:
-//     1) Modified an item style color in your ImPlotStyle to anything other than IMPLOT_AUTO_COL.
-//     2) Pushed an item style color using PushStyleColor().
-//     3) Set the next item style with a SetNextXXXStyle function.
-
-// Add a new colormap. The color data will be copied. The colormap can be used by pushing either the returned index or the
-// string name with PushColormap. The colormap name must be unique and the size must be greater than 1. You will receive
-// an assert otherwise! By default colormaps are considered to be qualitative (i.e. discrete). If you want to create a
-// continuous colormap, set #qual=false. This will treat the colors you provide as keys, and ImPlot will build a linearly
-// interpolated lookup table. The memory footprint of this table will be exactly ((size-1)*255+1)*4 bytes.
-IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImVec4* cols, int size, bool qual=true);
-IMPLOT_API ImPlotColormap AddColormap(const char* name, const ImU32*  cols, int size, bool qual=true);
-
-// Returns the number of available colormaps (i.e. the built-in + user-added count).
-IMPLOT_API int GetColormapCount();
-// Returns a null terminated string name for a colormap given an index. Returns NULL if index is invalid.
-IMPLOT_API const char* GetColormapName(ImPlotColormap cmap);
-// Returns an index number for a colormap given a valid string name. Returns -1 if name is invalid.
-IMPLOT_API ImPlotColormap GetColormapIndex(const char* name);
-
-// Temporarily switch to one of the built-in (i.e. ImPlotColormap_XXX) or user-added colormaps (i.e. a return value of AddColormap). Don't forget to call PopColormap!
-IMPLOT_API void PushColormap(ImPlotColormap cmap);
-// Push a colormap by string name. Use built-in names such as "Default", "Deep", "Jet", etc. or a string you provided to AddColormap. Don't forget to call PopColormap!
-IMPLOT_API void PushColormap(const char* name);
-// Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count.
-IMPLOT_API void PopColormap(int count = 1);
-
-// Returns the next color from the current colormap and advances the colormap for the current plot.
-// Can also be used with no return value to skip colors if desired. You need to call this between Begin/EndPlot!
-IMPLOT_API ImVec4 NextColormapColor();
-
-// Colormap utils. If cmap = IMPLOT_AUTO (default), the current colormap is assumed.
-// Pass an explicit colormap index (built-in or user-added) to specify otherwise.
-
-// Returns the size of a colormap.
-IMPLOT_API int GetColormapSize(ImPlotColormap cmap = IMPLOT_AUTO);
-// Returns a color from a colormap given an index >= 0 (modulo will be performed).
-IMPLOT_API ImVec4 GetColormapColor(int idx, ImPlotColormap cmap = IMPLOT_AUTO);
-// Sample a color from the current colormap given t between 0 and 1.
-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* 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.
-IMPLOT_API bool ColormapButton(const char* label, const ImVec2& size = ImVec2(0,0), ImPlotColormap cmap = IMPLOT_AUTO);
-
-// When items in a plot sample their color from a colormap, the color is cached and does not change
-// unless explicitly overriden. Therefore, if you change the colormap after the item has already been plotted,
-// item colors will NOT update. If you need item colors to resample the new colormap, then use this
-// function to bust the cached colors. If #plot_title_id is NULL, then every item in EVERY existing plot
-// will be cache busted. Otherwise only the plot specified by #plot_title_id will be busted. For the
-// latter, this function must be called in the same ImGui ID scope that the plot is in. You should rarely if ever
-// need this function, but it is available for applications that require runtime colormap swaps (e.g. Heatmaps demo).
-IMPLOT_API void BustColorCache(const char* plot_title_id = NULL);
-
-//-----------------------------------------------------------------------------
-// [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).
-IMPLOT_API void ItemIcon(const ImVec4& col);
-IMPLOT_API void ItemIcon(ImU32 col);
-IMPLOT_API void ColormapIcon(ImPlotColormap cmap);
-
-// Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot.
-IMPLOT_API ImDrawList* GetPlotDrawList();
-// Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot.
-IMPLOT_API void PushPlotClipRect(float expand=0);
-// Pop plot clip rect. Call between Begin/EndPlot.
-IMPLOT_API void PopPlotClipRect();
-
-// Shows ImPlot style selector dropdown menu.
-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).
-IMPLOT_API void ShowUserGuide();
-// Shows ImPlot metrics/debug information window.
-IMPLOT_API void ShowMetricsWindow(bool* p_popen = NULL);
-
-//-----------------------------------------------------------------------------
-// [SECTION] Demo
-//-----------------------------------------------------------------------------
-
-// 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 << 20,
-    ImPlotFlags_YAxis3 = 1 << 21,
-};
-
-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