[Feature] remove stride and offset from ImPlotSpec

[rorschach-py]

Stride and offset are attributes of plot data, other members in ImPlotSpec are attributes of plot style.
It would be better to move stride and offset member from ImPlotSpec to function args or somewhere else, so that a single ImPlotSpec variable can serve as predefined plot style for multiple datasets with different memory layouts, thereby separating data from presentation.

[epezent]

@brenocq asked me to weigh in on this, so here's my take.

1. On one hand, you have a completely valid point -- currently Offset and Stride are the only ImPlotSpec variables pertaining to data. Everything else is related to styling. Maybe Flags is a a bit odd as well if the goal is to generalize ImPlotSpec across multiple datasets and PlotX functions.
2. On the other hand, ImPlotSpec was our solution to not only a better styling API, but reducing the number of advanced args passed to PlotX functions. I would be ok moving stride and offset back into the plot signature, except that ...
3. Feat: Per-Index Color/Size Support with ImPlotSpec #672 will muddy the waters a bit, since e.g. ImU32 FillColors* will technically contain data (same is true for other array fieilds being added). We can't reasonably extend every PlotX function with the args needed to support this feature.

Given (2) and (3), I'll float two options:

1. Keep things the way they are: ImPlotSpec may contain data and styling parameters. @rorschach-py can get by doing something like:

ImPlotSpec myStyle = {...};
...
auto plot1Spec = myStyle;
plot1Spec.Offset = ...;
plot1Spec.Stride = ...;
ImPlot::PlotX(...., plot1Spec);
...
auto plot2Spec = myStyle;
plot2Spec.Offset = ...;
plot2Spec.Stride = ...;
ImPlot::PlotX(..., plot2Spec);

2. Completely decouple advanced data and styling parameters into two structures optionally passed to every PlotX function.

struct ImPlotSpec {
  // everything in ImPlotSpec sans Offset/Stride/Flags
};

struct ImPlotExtraData {   // naming is hard :/
  int Offset;
  int Stride;
  int Flags;
  ImU32*  FillColors = nullptr
  ...
}

IMPLOT_TMP void PlotLine(const char* label_id, const T* values, int count, double xscale=1, double xstart=0, const ImPlotSpec& spec=ImPlotSpec(), const ImPlotExtraData& extra_data=ImPlotData());

I'm not terribly opinionated here. (1) is the easy way out and I honestly support it, (2) feels like the better engineering approach (but we'd need a better name than ImPlotExtraData!).

@brenocq , what are your thoughts?

[brenocq]

Thank you for the comment @epezent! While I can see the advantages of decoupling data and styling, I personally don't like that the user would need to remember that FillColor is in one struct, and FillColors is on another struct. Since it's still possible to have a global ImPlotSpec style that is modified locally for each PlotX, I'm learning more towards option (1).

[rorschach-py]

@epezent Think of per-index style value as just another plot data, tread them as such.
Here's my approach: opengl glVertexArrayAttribFormat() like api style, maybe ugly for c++.

// constant plot style
struct ImPlotSpec {
    ImVec4          LineColor       = IMPLOT_AUTO_COL;       
    float           Size            = 5;
    ......
};

// per-index plot style binding point.
// 0: this attribute is scalar and value is taken form corresponding member in ImPlotSpec.
// N: this attribute is per-index and value is taken from data_layout[N] in function param.
struct ImPlotSpec_Binding {
    int   LineColor   = 0;    
    int   Size        = 0;    
    ......
};

// General vector data type for both plot data and per-index style
struct ImPlotDataLayout {
    int stride, offset;
    void* values;
};

// plot data use fixed binding point, plot style use variable binding point.
// Y is map to data_layout[0]
void PlotLine(const char* label_id, ImPlotDataLayout *data_layout, int count, ImPlotSpec spec, ImPlotSpec_Binding bind);

// X -> data_layout[0]
// Y -> data_layout[1]
void PlotScatter(const char* label_id, ImPlotDataLayout *data_layout, int count, ImPlotSpec spec, ImPlotSpec_Binding bind);

// Candlestick plot needs 5 binding point.
// X -> data_layout[0]
// open  -> data_layout[1]
// close -> data_layout[2]
// low   -> data_layout[3]
// high  -> data_layout[4]
void PlotCandlestick(const char* label_id, ImPlotDataLayout *data_layout, int count, ImPlotSpec spec, ImPlotSpec_Binding bind);

Example1: packed data struct

struct SAMPLE
{
    float x,y;
    ImVec4 color;
    int size;
}data[100]={...};

ImPlotDataLayout layout[]={
    {sizeof(SAMPLE), offsetof(SAMPLE, x), &data[0]},     // bind point 0
    {sizeof(SAMPLE), offsetof(SAMPLE, y), &data[0]},     // bind point 1
    {sizeof(SAMPLE), offsetof(SAMPLE, color), &data[0]}, // bind point 2
    {sizeof(SAMPLE), offsetof(SAMPLE, size), &data[0]},  // bind point 3
};

ImPlotSpec style = {
    .LineColor = ImVec4(...);   // constant color
    .Size = 5;                  // constant size
};

// draw line with constant line color and size
PlotLine("X1", layout, 100, style);

// draw scatter with constant line color and per-index size taken from data[].size
PlotScatter("X2", layout, 100, style, (ImPlotSpec_Binding){.LineColor=0, .Size=2});

Example2: planar data struct

float x[100], y[100];
ImVec4 color[100];
int size[100];

ImPlotDataLayout layout[]={
    {sizeof(x),     0, &x[0]},     // bind point 0
    {sizeof(y),     0, &y[0]},     // bind point 1
    {sizeof(color), 0, &color[0]}, // bind point 2
    {sizeof(size),  0, &size[0]},  // bind point 3
};

// exactly same api call as Example1
PlotScatter("X2", layout, 100, style, (ImPlotSpec_Binding){.LineColor=0, .Size=2});