From 92fa416657474d889b5e57793376eb9e75a070f2 Mon Sep 17 00:00:00 2001 From: Duncan Calvert Date: Mon, 21 Jun 2021 08:07:16 -0500 Subject: [PATCH] [API] Include ImPlot (#56) * Add implot submodule. * Add implot to generateLibs * Add _implot.h * Add placeholder ImPlot java classes. * Create demo window. * Try to show the ImPlot demo in the window. * Create ImPlot context. * Fix final check. * Implement ImPlotFlags. * Implement the rest of the enums. * Make classes final. * Implement ImPlotContext and related methods * Added more methods to ImPlot wrapper (mostly plot utils) * Implement ImPlotPoint * Implement ImPlotRange * Switch native method to static in ImPlotPoint * Implement ImPlotLimits * Finish ImPlot Plot Utils bindings * Implement more ImPlot methods (Miscellaneous) * Implement more ImPlot methods (Legend utils/tools) * Implement more ImPlot methods (Drag and drop utils) * Implement more ImPlot methods (Plot tools) * Implement more ImPlot methods (most plot items) * Fix compile error (casting to double and not Double) * Fix ImDrawData.getCmdListCmdBufferTextureId() * Implement more ImPlot methods (rest of plot items) (except for PlotImage, which is not currently supported) * Fix ImGui binding problems due to API changes * Adhere to style guidelines. * Fix imguizmo submodule * Fix API * Implement ImPlotStyle * Implement more ImPlot methods (Plot and Item styling) * Implement remainder of ImPlot methods (Colormaps) * Modify ImPlot example program * Fix ImPlot example program bug * ImPlot bugfixes * Update ImPlot Demo * Revert merge errors. * Make the submodules the version on master. * Fix URL/style in ExampleImPlot * Fix merge conflicts with example ImPlot context creation * Remove unneccesary static block for field declarations * Revert libimgui-java64.so * Change construction to use define (vs passing a pointer) * Fixed memory leaks Changed ImPlotLimits, ImPlotRange, and ImPlotPoint to extend ImGuiStructDestroyable instead of ImGuiStruct so user-created instances can be destroyed. Methods that create instances that must be destroyed manually specify this in the docs. * Fix style violations * Fix compile error * Replace exception type Co-authored-by: Perry MacMurray Co-authored-by: Perry Co-authored-by: SpaiR --- .gitmodules | 3 + .../groovy/imgui/generate/GenerateLibs.groovy | 2 +- example/src/main/java/ExampleImPlot.java | 60 + example/src/main/java/Extra.java | 6 + example/src/main/java/Main.java | 2 + .../java/imgui/extension/implot/ImPlot.java | 1761 +++++++++++++++++ .../imgui/extension/implot/ImPlotContext.java | 9 + .../imgui/extension/implot/ImPlotLimits.java | 119 ++ .../imgui/extension/implot/ImPlotPoint.java | 55 + .../imgui/extension/implot/ImPlotRange.java | 58 + .../imgui/extension/implot/ImPlotStyle.java | 525 +++++ .../implot/flag/ImPlotAxisFlags.java | 37 + .../extension/implot/flag/ImPlotBin.java | 15 + .../extension/implot/flag/ImPlotCol.java | 57 + .../extension/implot/flag/ImPlotColormap.java | 39 + .../extension/implot/flag/ImPlotFlags.java | 36 + .../extension/implot/flag/ImPlotLocation.java | 25 + .../extension/implot/flag/ImPlotMarker.java | 30 + .../implot/flag/ImPlotOrientation.java | 11 + .../extension/implot/flag/ImPlotStyleVar.java | 62 + .../extension/implot/flag/ImPlotYAxis.java | 13 + imgui-binding/src/main/native/_implot.h | 6 + include/implot | 1 + 23 files changed, 2931 insertions(+), 1 deletion(-) create mode 100644 example/src/main/java/ExampleImPlot.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlot.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlotContext.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlotLimits.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlotPoint.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlotRange.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/ImPlotStyle.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotAxisFlags.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotBin.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotCol.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotColormap.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotFlags.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotLocation.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotMarker.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotOrientation.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotStyleVar.java create mode 100644 imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotYAxis.java create mode 100644 imgui-binding/src/main/native/_implot.h create mode 160000 include/implot diff --git a/.gitmodules b/.gitmodules index 9b65434..743a143 100644 --- a/.gitmodules +++ b/.gitmodules @@ -10,3 +10,6 @@ [submodule "include/imguizmo"] path = include/imguizmo url = https://github.com/CedricGuillemet/ImGuizmo.git +[submodule "include/implot"] + path = include/implot + url = https://github.com/epezent/implot.git diff --git a/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy b/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy index a17895b..2829a84 100644 --- a/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy +++ b/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy @@ -46,7 +46,7 @@ class GenerateLibs extends DefaultTask { // Copy ImGui h/cpp files project.copy { CopySpec spec -> - ['include/imgui', 'include/imnodes', 'include/imgui-node-editor', 'include/imguizmo'].each { + ['include/imgui', 'include/imnodes', 'include/imgui-node-editor', 'include/imguizmo', 'include/implot'].each { spec.from(project.rootProject.file(it)) { CopySpec s -> s.include('*.h', '*.cpp', '*.inl') } } spec.from(project.rootProject.file('imgui-binding/src/main/native')) diff --git a/example/src/main/java/ExampleImPlot.java b/example/src/main/java/ExampleImPlot.java new file mode 100644 index 0000000..6ab44f4 --- /dev/null +++ b/example/src/main/java/ExampleImPlot.java @@ -0,0 +1,60 @@ +import imgui.extension.implot.ImPlot; +import imgui.extension.implot.ImPlotContext; +import imgui.flag.ImGuiCond; +import imgui.internal.ImGui; +import imgui.type.ImBoolean; + +import java.awt.*; +import java.net.URI; + +public class ExampleImPlot { + private static final String URL = "https://github.com/epezent/implot/tree/555ff68"; + private static final ImBoolean showDemo = new ImBoolean(false); + + private static final Integer[] xs = {0, 1, 2, 3, 4, 5}; + private static final Integer[] ys = {0, 1, 2, 3, 4, 5}; + + private final static ImPlotContext IMPLOT_CONTEXT; + + static { + IMPLOT_CONTEXT = ImPlot.createContext(); + } + + public static void show(ImBoolean showImPlotWindow) { + ImGui.setNextWindowSize(500, 400, ImGuiCond.Once); + ImGui.setNextWindowPos(ImGui.getMainViewport().getPosX() + 100, ImGui.getMainViewport().getPosY() + 100, ImGuiCond.Once); + if (ImGui.begin("ImPlot Demo", showImPlotWindow)) { + ImGui.text("This a demo for ImPlot"); + + ImGui.alignTextToFramePadding(); + ImGui.text("Repo:"); + ImGui.sameLine(); + if (ImGui.button(URL)) { + try { + Desktop.getDesktop().browse(new URI(URL)); + } catch (Exception e) { + e.printStackTrace(); + } + } + + ImGui.checkbox("Show ImPlot Built-In Demo", showDemo); + + if (ImPlot.beginPlot("Example Plot")) { + ImPlot.plotLine("Line", xs, ys); + ImPlot.plotBars("Bars", xs, ys); + ImPlot.endPlot(); + } + + if (ImPlot.beginPlot("Example Scatterplot")) { + ImPlot.plotScatter("Scatter", xs, ys); + ImPlot.endPlot(); + } + + if (showDemo.get()) { + ImPlot.showDemoWindow(showDemo); + } + } + + ImGui.end(); + } +} diff --git a/example/src/main/java/Extra.java b/example/src/main/java/Extra.java index f338396..c9ea60d 100644 --- a/example/src/main/java/Extra.java +++ b/example/src/main/java/Extra.java @@ -7,6 +7,7 @@ public class Extra { private static final ImBoolean SHOW_IMNODES_DEMO_WINDOW = new ImBoolean(false); private static final ImBoolean SHOW_IMGUI_NODE_EDITOR_DEMO_WINDOW = new ImBoolean(false); private static final ImBoolean SHOW_DRAG_N_DROP_WINDOW = new ImBoolean(false); + private static final ImBoolean SHOW_IMPLOT_DEMO_WINDOW = new ImBoolean(false); private static final ImBoolean SHOW_IMGUIZMO_DEMO = new ImBoolean(false); private static final Graph GRAPH = new Graph(); @@ -17,6 +18,7 @@ public class Extra { ImGui.checkbox("Show ImNodes Demo Window", SHOW_IMNODES_DEMO_WINDOW); ImGui.checkbox("Show imgui-node-editor Demo Window", SHOW_IMGUI_NODE_EDITOR_DEMO_WINDOW); ImGui.checkbox("Show Drag'N'Drop Demo Window", SHOW_DRAG_N_DROP_WINDOW); + ImGui.checkbox("Show ImPlot Demo Window", SHOW_IMPLOT_DEMO_WINDOW); ImGui.checkbox("Show ImGuizmo Demo Window", SHOW_IMGUIZMO_DEMO); if (SHOW_DEMO_WINDOW.get()) { @@ -38,5 +40,9 @@ public class Extra { if (SHOW_DRAG_N_DROP_WINDOW.get()) { ExampleDragAndDrop.show(SHOW_DRAG_N_DROP_WINDOW); } + + if (SHOW_IMPLOT_DEMO_WINDOW.get()) { + ExampleImPlot.show(SHOW_IMPLOT_DEMO_WINDOW); + } } } diff --git a/example/src/main/java/Main.java b/example/src/main/java/Main.java index bf445bf..fa4b0bc 100644 --- a/example/src/main/java/Main.java +++ b/example/src/main/java/Main.java @@ -2,6 +2,8 @@ import imgui.*; import imgui.app.Application; import imgui.app.Configuration; import imgui.extension.imnodes.ImNodes; +import imgui.extension.implot.ImPlot; +import imgui.extension.implot.ImPlotContext; import imgui.flag.ImGuiConfigFlags; import imgui.flag.ImGuiInputTextFlags; import imgui.type.ImString; diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlot.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlot.java new file mode 100644 index 0000000..166794c --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlot.java @@ -0,0 +1,1761 @@ +package imgui.extension.implot; + +import imgui.ImDrawList; +import imgui.ImVec2; +import imgui.ImVec4; +import imgui.extension.implot.flag.ImPlotYAxis; +import imgui.flag.ImGuiCond; +import imgui.flag.ImGuiMouseButton; +import imgui.type.ImBoolean; +import imgui.type.ImDouble; + +public final class ImPlot { + private static final ImDrawList IM_DRAW_LIST = new ImDrawList(0); + + private static final ImPlotContext IMPLOT_CONTEXT = new ImPlotContext(0); + private static final ImPlotPoint IMPLOT_POINT = new ImPlotPoint(0); + private static final ImPlotLimits IMPLOT_LIMITS = new ImPlotLimits(0); + private static final ImPlotStyle IMPLOT_STYLE = new ImPlotStyle(0); + + private ImPlot() { + + } + + /*JNI + #include "_common.h" + #include "_implot.h" + + */ + + //----------------------------------------------------------------------------- + // ImPlot Context + //----------------------------------------------------------------------------- + + /** + * Creates a new ImPlot context. Call this after ImGui.createContext(). + */ + public static ImPlotContext createContext() { + IMPLOT_CONTEXT.ptr = nCreateContext(); + return IMPLOT_CONTEXT; + } + + private static native long nCreateContext(); /* + return (intptr_t)ImPlot::CreateContext(); + */ + + /** + * Destroys an ImPlot context. Call this before ImGui.destroyContext(). NULL = destroy current context. + */ + public static void destroyContext(final ImPlotContext ctx) { + nDestroyContext(ctx.ptr); + } + + private static native void nDestroyContext(long ctx); /* + ImPlot::DestroyContext((ImPlotContext*)ctx); + */ + + /** + * Returns the current ImPlot context. NULL if no context has ben set. + */ + public static ImPlotContext getCurrentContext() { + IMPLOT_CONTEXT.ptr = nGetCurrentContext(); + return IMPLOT_CONTEXT; + } + + private static native long nGetCurrentContext(); /* + return (intptr_t)ImPlot::GetCurrentContext(); + */ + + /** + * Sets the current ImPlot context. + */ + public static void setCurrentContext(final ImPlotContext ctx) { + nSetCurrentContext(ctx.ptr); + } + + private static native void nSetCurrentContext(long ctx); /* + ImPlot::SetCurrentContext((ImPlotContext*)ctx); + */ + + //----------------------------------------------------------------------------- + // 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 (ImPlot.beginPlot(...)) { + * ImPlot.plotLine(...); + * ... + * ImPlot.endPlot(); + * } + * + * Important notes: + * + * - #titleID 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"). + */ + public static native boolean beginPlot(String titleID); /* + return ImPlot::BeginPlot(titleID); + */ + + /** + * Starts a 2D plotting context. If this function returns true, EndPlot() MUST + * be called! You are encouraged to use the following convention: + * + * if (ImPlot.beginPlot(...)) { + * ImPlot.plotLine(...); + * ... + * ImPlot.endPlot(); + * } + * + * Important notes: + * + * - #titleID 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 #xLabel and/or #yLabel are provided, axes labels will be displayed. + */ + public static native boolean beginPlot(String titleID, String xLabel, String yLabel); /* + return ImPlot::BeginPlot(titleID, xLabel, yLabel); + */ + + /** + * Starts a 2D plotting context. If this function returns true, EndPlot() MUST + * be called! You are encouraged to use the following convention: + * + * if (ImPlot.beginPlot(...)) { + * ImPlot.plotLine(...); + * ... + * ImPlot.endPlot(); + * } + * + * Important notes: + * + * - #titleID 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 #xLabel and/or #yLabel 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). + */ + public static boolean beginPlot(final String titleID, final String xLabel, final String yLabel, final ImVec2 size) { + return nBeginPlot(titleID, xLabel, yLabel, size.x, size.y); + } + + private static native boolean nBeginPlot(String titleID, String xLabel, String yLabel, float x, float y); /* + return ImPlot::BeginPlot(titleID, xLabel, yLabel, ImVec2(x, y)); + */ + + /** + * Starts a 2D plotting context. If this function returns true, EndPlot() MUST + * be called! You are encouraged to use the following convention: + * + * if (ImPlot.beginPlot(...)) { + * ImPlot.plotLine(...); + * ... + * ImPlot.endPlot(); + * } + * + * Important notes: + * + * - #titleID 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 #xLabel and/or #yLabel 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). + * - See ImPlotFlags and ImPlotAxisFlags for more available options. + */ + public static boolean beginPlot(final String titleID, final String xLabel, final String yLabel, final ImVec2 size, final int flags, final int xFlags, final int yFlags) { + return nBeginPlot(titleID, xLabel, yLabel, size.x, size.y, flags, xFlags, yFlags); + } + + private static native boolean nBeginPlot(String titleID, String xLabel, String yLabel, float x, float y, int flags, int xFlags, int yFlags); /* + return ImPlot::BeginPlot(titleID, xLabel, yLabel, ImVec2(x, y), flags, xFlags, yFlags); + */ + + /** + * Starts a 2D plotting context. If this function returns true, EndPlot() MUST + * be called! You are encouraged to use the following convention: + * + * if (ImPlot.beginPlot(...)) { + * ImPlot.plotLine(...); + * ... + * ImPlot.endPlot(); + * } + * + * Important notes: + * + * - #titleID 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 #xLabel and/or #yLabel 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. + */ + public static boolean beginPlot(final String titleID, + final String xLabel, + final String yLabel, + final ImVec2 size, + final int flags, + final int xFlags, + final int yFlags, + final int y2Flags, + final int y3Flags, + final String y2Label, + final String y3Label) { + return nBeginPlot(titleID, xLabel, yLabel, size.x, size.y, flags, xFlags, yFlags, y2Flags, y3Flags, y2Label, y3Label); + } + + private static native boolean nBeginPlot(String titleID, + String xLabel, + String yLabel, + float x, + float y, + int flags, + int xFlags, + int yFlags, + int y2Flags, + int y3Flags, + String y2Label, + String y3Label); /* + return ImPlot::BeginPlot(titleID, + xLabel, + yLabel, + ImVec2(x, y), + flags, + xFlags, + yFlags, + y2Flags, + y3Flags, + y2Label, + y3Label); + */ + + /** + * Only call EndPlot() if beginPlot() returns true! Typically called at the end + * of an if statement conditioned on BeginPlot(). See example in beginPlot(). + */ + public static native void endPlot(); /* + ImPlot::EndPlot(); + */ + + //----------------------------------------------------------------------------- + // Plot Items + //----------------------------------------------------------------------------- + + /** + * Make sure to initialize xsOut and ysOut with length xs.length, ys.length before passing them, or data may be lost/errors may occur + */ + private static void convertArrays(final T[] xs, final T[] ys, final double[] xsOut, final double[] ysOut) { + if (xs.length != ys.length) { + throw new IllegalArgumentException("Invalid length for arrays"); + } + + for (int i = 0; i < xs.length; i++) { + xsOut[i] = xs[i].doubleValue(); + ysOut[i] = ys[i].doubleValue(); + } + } + + /** + * Plots a standard 2D line plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotLine(final String labelID, final T[] xs, final T[] ys) { + plotLine(labelID, xs, ys, 0); + } + + /** + * Plots a standard 2D line plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotLine(final String labelID, final T[] xs, final T[] ys, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotLine(labelID, x, y, x.length, offset); + } + + private static native void nPlotLine(String labelID, double[] xs, double[] ys, int size, int offset); /* + ImPlot::PlotLine(labelID, xs, ys, size, offset); + */ + + /** + * Plots a standard 2D scatter plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotScatter(final String labelID, final T[] xs, final T[] ys) { + plotScatter(labelID, xs, ys, 0); + } + + /** + * Plots a standard 2D scatter plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotScatter(final String labelID, final T[] xs, final T[] ys, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotScatter(labelID, x, y, x.length, offset); + } + + private static native void nPlotScatter(String labelID, double[] xs, double[] ys, int size, int offset); /* + ImPlot::PlotScatter(labelID, xs, ys, size, offset); + */ + + /** + * 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]. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotStairs(final String labelID, final T[] xs, final T[] ys) { + plotStairs(labelID, xs, ys, 0); + } + + /** + * Plots a a stairstep graph. The y value is continued constantly from every x position, i.e. the interval [x[i], x[i+1]) has the value y[i]. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotStairs(final String labelID, final T[] xs, final T[] ys, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotStairs(labelID, x, y, x.length, offset); + } + + private static native void nPlotStairs(String labelID, double[] xs, double[] ys, int size, int offset); /* + ImPlot::PlotStairs(labelID, xs, ys, size, offset); + */ + + /** + * Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yRef (default 0) to +/-INFINITY for infinite fill extents. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotShaded(final String labelID, final T[] xs, final T[] ys, final int yRef) { + plotShaded(labelID, xs, ys, yRef, 0); + } + + /** + * Plots a shaded (filled) region between two lines, or a line and a horizontal reference. Set yRef (default 0) to +/-INFINITY for infinite fill extents. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotShaded(final String labelID, final T[] xs, final T[] ys, final int yRef, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotShaded(labelID, x, y, x.length, yRef, offset); + } + + private static native void nPlotShaded(String labelID, double[] xs, double[] ys, int size, int yRef, int offset); /* + ImPlot::PlotShaded(labelID, xs, ys, size, yRef, offset); + */ + + /** + * Plots a vertical bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotBars(final String labelID, final T[] xs, final T[] ys) { + plotBars(labelID, xs, ys, 0.67f, 0); + } + + /** + * Plots a vertical bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + * @param width is in X units + */ + public static void plotBars(final String labelID, final T[] xs, final T[] ys, final float width) { + plotBars(labelID, xs, ys, width, 0); + } + + /** + * Plots a vertical bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + * @param width is in X units + */ + public static void plotBars(final String labelID, final T[] xs, final T[] ys, final float width, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotBars(labelID, x, y, x.length, width, offset); + } + + private static native void nPlotBars(String labelID, double[] xs, double[] ys, int size, float width, int offset); /* + ImPlot::PlotBars(labelID, xs, ys, size, width, offset); + */ + + /** + * Plots a horizontal bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotBarsH(final String labelID, final T[] xs, final T[] ys) { + plotBarsH(labelID, xs, ys, 0.67f, 0); + } + + /** + * Plots a horizontal bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + * @param height is in Y units + */ + public static void plotBarsH(final String labelID, final T[] xs, final T[] ys, final float height) { + plotBarsH(labelID, xs, ys, height, 0); + } + + /** + * Plots a horizontal bar graph. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + * @param height is in Y units + */ + public static void plotBarsH(final String labelID, final T[] xs, final T[] ys, final float height, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotBarsH(labelID, x, y, x.length, height, offset); + } + + private static native void nPlotBarsH(String labelID, double[] xs, double[] ys, int size, float height, int offset); /* + ImPlot::PlotBarsH(labelID, xs, ys, size, height, offset); + */ + + /** + * Plots vertical error bar. The labelID should be the same as the labelID of the associated line or bar plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotErrorBars(final String labelID, final T[] xs, final T[] ys, final T[] err) { + plotErrorBars(labelID, xs, ys, err, 0); + } + + /** + * Plots vertical error bar. The labelID should be the same as the labelID of the associated line or bar plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotErrorBars(final String labelID, final T[] xs, final T[] ys, final T[] err, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + final double[] errOut = new double[err.length]; + convertArrays(xs, ys, x, y); + convertArrays(xs, err, x, errOut); //It's easier here to just do the X array twice than process the err array alone + + nPlotErrorBars(labelID, x, y, errOut, x.length, offset); + } + + private static native void nPlotErrorBars(String labelID, double[] xs, double[] ys, double[] err, int size, int offset); /* + ImPlot::PlotErrorBars(labelID, xs, ys, err, size, offset); + */ + + /** + * Plots horizontal error bar. The labelID should be the same as the labelID of the associated line or bar plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotErrorBarsH(final String labelID, final T[] xs, final T[] ys, final T[] err) { + plotErrorBarsH(labelID, xs, ys, err, 0); + } + + /** + * Plots horizontal error bar. The labelID should be the same as the labelID of the associated line or bar plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotErrorBarsH(final String labelID, final T[] xs, final T[] ys, final T[] err, final int offset) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + final double[] errOut = new double[err.length]; + convertArrays(xs, ys, x, y); + convertArrays(xs, err, x, errOut); //It's easier here to just do the X array twice than process the err array alone + + nPlotErrorBarsH(labelID, x, y, errOut, x.length, offset); + } + + private static native void nPlotErrorBarsH(String labelID, double[] xs, double[] ys, double[] err, int size, int offset); /* + ImPlot::PlotErrorBarsH(labelID, xs, ys, err, size, offset); + */ + + /** + * Plots vertical stems. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotStems(final String labelID, final T[] values, final int yRef) { + plotStems(labelID, values, yRef, 0); + } + + /** + * Plots vertical stems. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotStems(final String labelID, final T[] values, final int yRef, final int offset) { + final double[] v = new double[values.length]; + for (int i = 0; i < values.length; i++) { + v[i] = values[i].doubleValue(); + } + + nPlotStems(labelID, v, v.length, yRef, offset); + } + + private static native void nPlotStems(String labelID, double[] values, int size, int yRef, int offset); /* + ImPlot::PlotStems(labelID, values, size, yRef, offset); + */ + + /** + * Plots infinite vertical lines (e.g. for references or asymptotes). + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotVLines(final String labelID, final T[] values) { + plotVLines(labelID, values, 0); + } + + /** + *Plots infinite vertical lines (e.g. for references or asymptotes). + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotVLines(final String labelID, final T[] values, final int offset) { + final double[] v = new double[values.length]; + for (int i = 0; i < values.length; i++) { + v[i] = values[i].doubleValue(); + } + + nPlotVLines(labelID, v, v.length, offset); + } + + private static native void nPlotVLines(String labelID, double[] values, int size, int offset); /* + ImPlot::PlotVLines(labelID, values, size, offset); + */ + + /** + * Plots infinite horizontal lines (e.g. for references or asymptotes). + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotHLines(final String labelID, final T[] values) { + plotHLines(labelID, values, 0); + } + + /** + * Plots infinite horizontal lines (e.g. for references or asymptotes). + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotHLines(final String labelID, final T[] values, final int offset) { + final double[] v = new double[values.length]; + for (int i = 0; i < values.length; i++) { + v[i] = values[i].doubleValue(); + } + + nPlotHLines(labelID, v, v.length, offset); + } + + private static native void nPlotHLines(String labelID, double[] values, int size, int offset); /* + ImPlot::PlotHLines(labelID, values, size, offset); + */ + + /** + * Plots a pie chart. If the sum of values > 1, each value will be normalized. Center and radius are in plot units. #label_fmt can be set to NULL for no labels. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotPieChart(final String[] labelIDs, final T[] values, final double x, final double y, final double radius) { + final double[] v = new double[values.length]; + for (int i = 0; i < values.length; i++) { + v[i] = values[i].doubleValue(); + } + + String labelIDsSs = ""; + boolean first = true; + int maxSize = 0; + for (String s : labelIDs) { + if (first) { + first = false; + continue; + } else { + labelIDsSs += "\n"; + } + if (s.length() > maxSize) { + maxSize = s.length(); + } + + labelIDsSs += s.replace("\n", ""); + } + + nPlotPieChart(labelIDsSs, maxSize, v, v.length, x, y, radius); + } + + //JNI function splits up passed string labelIDsSs to array for use in C++, as String[] is not converted by JNI + private static native void nPlotPieChart(String labelIDsSs, int strLen, double[] values, int size, double x, double y, double radius); /* + char** labelIDs = new char*[size]; + + for (int pos = 0; pos < size; pos++) { + char* str = new char[strLen + 1]; + char* str_i = str; + + while (*labelIDsSs != '\n' && *labelIDsSs != '\0') { + *str = *labelIDsSs; + labelIDsSs++; + str++; + } + labelIDsSs++; //move past \n + + labelIDs[pos] = str_i; + } + + ImPlot::PlotPieChart(labelIDs, values, size, x, y, radius); + + for (int i = 0; i < size; i++) { + delete labelIDs[i]; + } + delete[] labelIDs; + */ + + /** + * Plots a 2D heatmap chart. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + * @param values must have fixed dimensions (all arrays are same length) + */ + public static void plotHeatmap(final String labelID, final T[][] values, final int offset) { + final double[] v = new double[values.length * values[0].length]; + int pos = 0; + for (T[] a : values) { + for (T p : a) { + v[pos++] = p.doubleValue(); + } + } + + nPlotHeatmap(labelID, v, values[0].length, values.length); + } + + private static native void nPlotHeatmap(String labelID, double[] values, int rows, int cols); /* + ImPlot::PlotHeatmap(labelID, values, rows, cols); + */ + +// // 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. +// template IMPLOT_API double PlotHistogram(const char* labelID, 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 a horizontal histogram + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static double plotHistogram(final String labelID, final T[] values) { + final double[] v = new double[values.length]; + for (int i = 0; i < values.length; i++) { + v[i] = values[i].doubleValue(); + } + + return nPlotHistogram(labelID, v, v.length); + } + + private static native double nPlotHistogram(String labelID, double[] values, int size); /* + return ImPlot::PlotHistogram(labelID, values, size); + */ + + /** + * Plots two dimensional, bivariate histogram as a heatmap + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static double plotHistogram2D(final String labelID, final T[] xs, final T[] ys) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + return nPlotHistogram2D(labelID, x, y, x.length); + } + + private static native double nPlotHistogram2D(String labelID, double[] xs, double[] ys, int size); /* + return ImPlot::PlotHistogram2D(labelID, xs, ys, size); + */ + +// // +// template IMPLOT_API void PlotDigital(const char* labelID, const T* xs, const T* ys, int count, int offset=0, int stride=sizeof(T)); +// IMPLOT_API void PlotDigitalG(const char* labelID, ImPlotPoint (*getter)(void* data, int idx), void* data, int count, int offset=0); +// + + /** + * Plots digital data. Digital plots do not respond to y drag or zoom, and are always referenced to the bottom of the plot. + * Due to conversion from T to double, extremely large 64-bit integer (long) values may lose data! + */ + public static void plotDigital(final String labelID, final T[] xs, final T[] ys) { + final double[] x = new double[xs.length]; + final double[] y = new double[ys.length]; + convertArrays(xs, ys, x, y); + + nPlotDigital(labelID, x, y, x.length); + } + + private static native void nPlotDigital(String labelID, double[] xs, double[] ys, int size); /* + ImPlot::PlotDigital(labelID, xs, ys, size); + */ + + //TODO not yet supported +// // 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* labelID, 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 + */ + public static void plotText(final String text, final double x, final double y) { + plotText(text, x, y, false); + } + + /** + * Plots a centered text label at point x,y + */ + public static native void plotText(String text, double x, double y, boolean vertical); /* + ImPlot::PlotText(text, x, y, vertical); + */ + + /** + * Plots a dummy item (i.e. adds a legend entry colored by ImPlotCol_Line) + */ + public static native void plotDummy(String labelID); /* + ImPlot::PlotDummy(labelID); + */ + + //----------------------------------------------------------------------------- + // Plot Utils + //----------------------------------------------------------------------------- + + /** + * This function MUST be called BEFORE beginPlot! + * Set the axes range limits of the next plot. Call right before BeginPlot(). If ImGuiCond_Always is used, the axes limits will be locked. + */ + public static native void setNextPlotLimits(double xmin, double xmax, double ymin, double ymax, int imguicond); /* + ImPlot::SetNextPlotLimits(xmin, xmax, ymin, ymax, imguicond); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static native void setNextPlotLimitsX(double xmin, double xmax, int imguicond); /* + ImPlot::SetNextPlotLimitsX(xmin, xmax, imguicond); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static native void setNextPlotLimitsY(double ymin, double ymax, int imguicond); /* + ImPlot::SetNextPlotLimitsY(ymin, ymax, imguicond); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static void linkNextPlotLimits(final ImDouble xmin, final ImDouble xmax, final ImDouble ymin, final ImDouble ymax) { + linkNextPlotLimits(xmin, xmax, ymin, ymax, null, null, null, null); + } + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static void linkNextPlotLimits(final ImDouble xmin, final ImDouble xmax, final ImDouble ymin, final ImDouble ymax, final ImDouble ymin2, final ImDouble ymax2) { + linkNextPlotLimits(xmin, xmax, ymin, ymax, ymin2, ymax2, null, null); + } + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static void linkNextPlotLimits(final ImDouble xmin, final ImDouble xmax, final ImDouble ymin, final ImDouble ymax, final ImDouble ymin2, final ImDouble ymax2, final ImDouble ymin3, final ImDouble ymax3) { + nLinkNextPlotLimits(xmin.getData(), xmax.getData(), ymin.getData(), ymax.getData(), ymin2.getData(), ymax2.getData(), ymin3.getData(), ymax3.getData()); + } + + private static native void nLinkNextPlotLimits(double[] xmin, double[] xmax, double[] ymin, double[] ymax, double[] ymin2, double[] ymax2, double[] ymin3, double[] ymax3); /* + ImPlot::LinkNextPlotLimits(&xmin[0], &xmax[0], &ymin[0], &ymax[0], &ymin2[0], &ymax2[0], &ymin3[0], &ymax3[0]); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks). + */ + public static void fitNextPlotAxes() { + fitNextPlotAxes(true, true, true, true); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks). + */ + public static void fitNextPlotAxes(final boolean x, final boolean y) { + fitNextPlotAxes(x, y, true, true); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Fits the next plot axes to all plotted data if they are unlocked (equivalent to double-clicks). + */ + public static native void fitNextPlotAxes(boolean x, boolean y, boolean y2, boolean y3); /* + ImPlot::FitNextPlotAxes(x, y, y2, y3); + */ + + + /** + * This function MUST be called BEFORE beginPlot! + * Set the X axis ticks and optionally the labels for the next plot. + */ + public static void setNextPlotTicksX(final double xMin, final double xMax, final int nTicks) { + setNextPlotTicksX(xMin, xMax, nTicks, null, false); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Set the X axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keepDefault=true. + */ + public static void setNextPlotTicksX(final double xMin, final double xMax, final int nTicks, final String[] labels, final boolean keepDefault) { + final String[] labelStrings = new String[4]; + for (int i = 0; i < 4; i++) { + if (labels != null && i < labels.length) { + labelStrings[i] = labels[i]; + } else { + labelStrings[i] = null; + } + } + + nSetNextPlotTicksX(xMin, xMax, nTicks, labelStrings[0], labelStrings[1], labelStrings[2], labelStrings[3], keepDefault); + } + + private static native void nSetNextPlotTicksX(double xMin, double xMax, int nTicks, String s1, String s2, String s3, String s4, boolean keepDefault); /* + char* strings[] = {s1, s2, s3, s4}; + ImPlot::SetNextPlotTicksX(xMin, xMax, nTicks, strings, keepDefault); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * Set the Y axis ticks and optionally the labels for the next plot. + */ + public static void setNextPlotTicksY(final double xMin, final double xMax, final int nTicks) { + setNextPlotTicksY(xMin, xMax, nTicks, null, false, ImPlotYAxis.YAxis_1); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keepDefault=true. + */ + public static void setNextPlotTicksY(final double xMin, final double xMax, final int nTicks, final String[] labels, final boolean keepDefault) { + setNextPlotTicksY(xMin, xMax, nTicks, labels, keepDefault, ImPlotYAxis.YAxis_1); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Set the Y axis ticks and optionally the labels for the next plot. To keep the default ticks, set #keepDefault=true. + */ + public static void setNextPlotTicksY(final double xMin, final double xMax, final int nTicks, final String[] labels, final boolean keepDefault, final int yAxis) { + final String[] labelStrings = new String[4]; + for (int i = 0; i < 4; i++) { + if (labels != null && i < labels.length) { + labelStrings[i] = labels[i]; + } else { + labelStrings[i] = null; + } + } + + nSetNextPlotTicksY(xMin, xMax, nTicks, labelStrings[0], labelStrings[1], labelStrings[2], labelStrings[3], keepDefault, yAxis); + } + + public static native void nSetNextPlotTicksY(double xMin, double xMax, int nTicks, String s1, String s2, String s3, String s4, boolean keepDefault, int yAxis); /* + char* strings[] = {s1, s2, s3, s4}; + ImPlot::SetNextPlotTicksY(xMin, xMax, nTicks, strings, keepDefault, yAxis); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * 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. + */ + public static native void setNextPlotFormatX(String fmt); /* + ImPlot::SetNextPlotFormatX(fmt); + */ + + /** + * This function MUST be called BEFORE beginPlot! + * Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled. + */ + public static void setNextPlotFormatY(final String fmt) { + setNextPlotFormatY(fmt, ImPlotYAxis.YAxis_1); + } + + /** + * This function MUST be called BEFORE beginPlot! + * Set the format for numeric Y axis labels (default="%g"). Formated values will be doubles (i.e. don't supply %d, %i, etc.). Not applicable if ImPlotAxisFlags_Time enabled. + */ + public static native void setNextPlotFormatY(String fmt, int yAxis); /* + ImPlot::SetNextPlotFormatY(fmt); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * 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. + */ + public static native void setPlotYAxis(int yAxis); /* + ImPlot::SetPlotYAxis(yAxis); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Hides the next plot item. + */ + public static void hideNextItem() { + hideNextItem(true, ImGuiCond.Once); + } + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Hides the next plot item. Use ImGuiCond. Always if you need to forcefully set this every frame (default ImGuiCond.Once). + */ + public static native void hideNextItem(boolean hidden, int imguiCond); /* + ImPlot::HideNextItem(hidden, imguiCond); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Convert pixels to a position in the current plot's coordinate system. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImPlotPoint pixelsToPlot(final ImVec2 pix, final int yAxis) { + IMPLOT_POINT.ptr = nPixelsToPlot(pix.x, pix.y, yAxis); + return IMPLOT_POINT; + } + + /** + * This function MUST be called BETWEEN begin/endPlot! + * The returned ImPlotPoint should be manually deallocated with destroy()! + * Convert pixels to a position in the current plot's coordinate system. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImPlotPoint pixelsToPlot(final float x, final float y, final int yAxis) { + IMPLOT_POINT.ptr = nPixelsToPlot(x, y, yAxis); + return IMPLOT_POINT; + } + + private static native long nPixelsToPlot(float x, float y, int yAxis); /* + ImPlotPoint* p = new ImPlotPoint(ImPlot::PixelsToPlot(x, y, yAxis)); + return (intptr_t)p; + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Convert a position in the current plot's coordinate system to pixels. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImVec2 plotToPixels(final ImPlotPoint plt, final int yAxis) { + return plotToPixels(plt.getX(), plt.getY(), yAxis); + } + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Convert a position in the current plot's coordinate system to pixels. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImVec2 plotToPixels(final double x, final double y, final int yAxis) { + final ImVec2 value = new ImVec2(); + nPlotToPixels(x, y, yAxis, value); + return value; + } + + private static native void nPlotToPixels(double x, double y, int yAxis, ImVec2 vec); /* + Jni::ImVec2Cpy(env, ImPlot::PlotToPixels(x, y, yAxis), vec); + */ + + + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Get the current Plot position (top-left) in pixels. + */ + public static ImVec2 getPlotPos() { + final ImVec2 value = new ImVec2(); + getPlotPos(value); + return value; + } + + public static native void getPlotPos(ImVec2 vec); /* + Jni::ImVec2Cpy(env, ImPlot::GetPlotPos(), vec); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Get the current Plot size in pixels. + */ + public static ImVec2 getPlotSize() { + final ImVec2 value = new ImVec2(); + getPlotSize(value); + return value; + } + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Get the current Plot size in pixels. + */ + public static native void getPlotSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, ImPlot::GetPlotSize(), vec); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Returns true if the plot area in the current plot is hovered. + */ + public static native boolean isPlotHovered(); /* + return ImPlot::IsPlotHovered(); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Returns true if the XAxis plot area in the current plot is hovered. + */ + public static native boolean isPlotXAxisHovered(); /* + return ImPlot::IsPlotXAxisHovered(); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Returns true if the YAxis[n] plot area in the current plot is hovered. + */ + public static native boolean isPlotYAxisHovered(int yAxis); /* + return ImPlot::IsPlotYAxisHovered(yAxis); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * The returned ImPlotPoint should be manually deallocated with destroy()! + * Returns the mouse position in x,y coordinates of the current plot. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImPlotPoint getPlotMousePos(final int yAxis) { + IMPLOT_POINT.ptr = nGetPlotMousePos(yAxis); + return IMPLOT_POINT; + } + + private static native long nGetPlotMousePos(int yAxis); /* + ImPlotPoint* p = new ImPlotPoint(ImPlot::GetPlotMousePos(yAxis)); + return (intptr_t)p; + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * The returned ImPlotLimits should be manually deallocated with destroy()! + * Returns the current plot axis range. A negative yAxis uses the current value of SetPlotYAxis (ImPlotYAxis_1 initially). + */ + public static ImPlotLimits getPlotLimits(final int yAxis) { + IMPLOT_LIMITS.ptr = nGetPlotLimits(yAxis); + return IMPLOT_LIMITS; + } + + private static native long nGetPlotLimits(int yAxis); /* + ImPlotLimits* p = new ImPlotLimits(ImPlot::GetPlotLimits(yAxis)); + return (intptr_t)p; + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Returns true if the current plot is being box selected. + */ + public static native boolean isPlotSelected(); /* + return ImPlot::IsPlotSelected(); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * The returned ImPlotLimits should be manually deallocated with destroy()! + * Returns the current plot box selection bounds. + */ + public static ImPlotLimits getPlotSelection(final int yAxis) { + IMPLOT_LIMITS.ptr = nGetPlotSelection(yAxis); + return IMPLOT_LIMITS; + } + + private static native long nGetPlotSelection(int yAxis); /* + ImPlotLimits* p = new ImPlotLimits(ImPlot::GetPlotSelection(yAxis)); + return (intptr_t)p; + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Returns true if the current plot is being queried or has an active query. Query must be enabled with ImPlotFlags_Query. + */ + public static native boolean isPlotQueried(); /* + return ImPlot::IsPlotQueried(); + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * The returned ImPlotLimits should be manually deallocated with destroy()! + * Returns the current plot query bounds. Query must be enabled with ImPlotFlags_Query. + */ + public static ImPlotLimits getPlotQuery(final int yAxis) { + IMPLOT_LIMITS.ptr = nGetPlotQuery(yAxis); + return IMPLOT_LIMITS; + } + + private static native long nGetPlotQuery(int yAxis); /* + ImPlotLimits* p = new ImPlotLimits(ImPlot::GetPlotQuery(yAxis)); + return (intptr_t)p; + */ + + /** + * This function MUST be called BETWEEN begin/endPlot! + * Set the current plot query bounds. Query must be enabled with ImPlotFlags_Query. + */ + public static void setPlotQuery(final ImPlotLimits query, final int yAxis) { + nSetPlotQuery(query.ptr, yAxis); + } + + private static native void nSetPlotQuery(long ptr, int yAxis); /* + ImPlotLimits* query = (ImPlotLimits*)ptr; + ImPlot::SetPlotQuery(*query, yAxis); + */ + + //----------------------------------------------------------------------------- + // Plot Tools + //----------------------------------------------------------------------------- + + /** + * Shows an annotation callout at a chosen point. + * Uses default color + */ + public static void annotate(final double x, final double y, final ImVec2 pixOffset, final String... fmt) { + annotate(x, y, pixOffset, new ImVec4(0, 0, 0, 0), fmt); + } + + /** + * Shows an annotation callout at a chosen point. + */ + public static void annotate(final double x, final double y, final ImVec2 pixOffset, final ImVec4 color, final String... fmt) { + nAnnotate(x, y, pixOffset.x, pixOffset.y, color.w, color.x, color.y, color.z, + fmt.length > 0 ? fmt[0] : null, + fmt.length > 1 ? fmt[1] : null, + fmt.length > 2 ? fmt[2] : null, + fmt.length > 3 ? fmt[3] : null, + fmt.length > 4 ? fmt[4] : null); + } + + private static native void nAnnotate(double x, double y, float pixX, float pixY, float colA, float colB, float colC, float colD, String a, String b, String c, String d, String e); /* + ImVec2 pixOffset(pixX, pixY); + ImVec4 col(colA, colB, colC, colD); + + if (b == nullptr) + ImPlot::Annotate(x, y, pixOffset, col, a); + else if (b == nullptr) + ImPlot::Annotate(x, y, pixOffset, col, a, b); + else if (b == nullptr) + ImPlot::Annotate(x, y, pixOffset, col, a, b, c); + else if (b == nullptr) + ImPlot::Annotate(x, y, pixOffset, col, a, b, c, d); + else + ImPlot::Annotate(x, y, pixOffset, col, a, b, c, d, e); + */ + + /** + * Shows an annotation callout at a chosen point, clamped inside the plot area. + * Uses default color + */ + public static void annotateClamped(final double x, final double y, final ImVec2 pixOffset, final String... fmt) { + annotateClamped(x, y, pixOffset, new ImVec4(0, 0, 0, 0), fmt); + } + + /** + * Shows an annotation callout at a chosen point, clamped inside the plot area. + */ + public static void annotateClamped(final double x, final double y, final ImVec2 pixOffset, final ImVec4 color, final String... fmt) { + nAnnotateClamped(x, y, pixOffset.x, pixOffset.y, color.w, color.x, color.y, color.z, + fmt.length > 0 ? fmt[0] : null, + fmt.length > 1 ? fmt[1] : null, + fmt.length > 2 ? fmt[2] : null, + fmt.length > 3 ? fmt[3] : null, + fmt.length > 4 ? fmt[4] : null); + } + + private static native void nAnnotateClamped(double x, double y, float pixX, float pixY, float colA, float colB, float colC, float colD, String a, String b, String c, String d, String e); /* + ImVec2 pixOffset(pixX, pixY); + ImVec4 col(colA, colB, colC, colD); + + if (b == nullptr) + ImPlot::AnnotateClamped(x, y, pixOffset, col, a); + else if (b == nullptr) + ImPlot::AnnotateClamped(x, y, pixOffset, col, a, b); + else if (b == nullptr) + ImPlot::AnnotateClamped(x, y, pixOffset, col, a, b, c); + else if (b == nullptr) + ImPlot::AnnotateClamped(x, y, pixOffset, col, a, b, c, d); + else + ImPlot::AnnotateClamped(x, y, pixOffset, col, a, b, c, d, e); + */ + +// +// // +// IMPLOT_API bool DragLineX(const char* id, double* xValue, bool showLabel = true, const ImVec4& col = IMPLOT_AUTO_COL, float thickness = 1); + + /** + * Shows a draggable vertical guide line at an x-value. + */ + public static boolean dragLineX(final String id, final double xValue, final boolean showLabel, final ImVec4 color, final float thickness) { + return nDragLineX(id, xValue, showLabel, color.w, color.x, color.y, color.z, thickness); + } + + private static native boolean nDragLineX(String id, double xValue, boolean showLabel, float w, float x, float y, float z, float thickness); /* + return ImPlot::DragLineX(id, &xValue, showLabel, ImVec4(w, x, y, z), thickness); + */ + + /** + * Shows a draggable horizontal guide line at a y-value. + */ + public static boolean dragLineY(final String id, final double yValue, final boolean showLabel, final ImVec4 color, final float thickness) { + return nDragLineY(id, yValue, showLabel, color.w, color.x, color.y, color.z, thickness); + } + + private static native boolean nDragLineY(String id, double yValue, boolean showLabel, float w, float x, float y, float z, float thickness); /* + return ImPlot::DragLineY(id, &yValue, showLabel, ImVec4(w, x, y, z), thickness); + */ + + /** + * Shows a draggable point at x,y. + */ + public static boolean dragPoint(final String id, final double x, final double y, final boolean showLabel, final ImVec4 color, final float radius) { + return nDragPoint(id, x, y, showLabel, color.w, color.x, color.y, color.z, radius); + } + + private static native boolean nDragPoint(String id, double xValue, double yValue, boolean showLabel, float w, float x, float y, float z, float radius); /* + return ImPlot::DragPoint(id, &xValue, &yValue, showLabel, ImVec4(w, x, y, z), radius); + */ + + + //----------------------------------------------------------------------------- + // Legend Utils and Tools + //----------------------------------------------------------------------------- + + /** + * Set the location of the current plot's legend + */ + public static native void setLegendLocation(int location, int orientation, boolean outside); /* + ImPlot::SetLegendLocation(location, orientation, outside); + */ + + /** + * Set the location of the current plot's mouse position text + */ + public static native void setMousePosLocation(int location); /* + ImPlot::SetMousePosLocation(location); + */ + + /** + * Returns true if a plot item legend entry is hovered. + */ + public static native boolean isLegendEntryHovered(String labelID); /* + return ImPlot::IsLegendEntryHovered(labelID); + */ + + /** + * Begin a popup for a legend entry. + */ + public static boolean beginLegendPopup(final String labelID) { + return beginLegendPopup(labelID, ImGuiMouseButton.Right); + } + + /** + * Begin a popup for a legend entry. + */ + public static native boolean beginLegendPopup(String labelID, int mouseButton); /* + return ImPlot::BeginLegendPopup(labelID, mouseButton); + */ + + /** + * End a popup for a legend entry. + */ + public static native void endLegendPopup(); /* + ImPlot::EndLegendPopup(); + */ + + //----------------------------------------------------------------------------- + // Drag and Drop Utils + //----------------------------------------------------------------------------- + + /** + * Turns the current plot's plotting area into a drag and drop target. Don't forget to call EndDragDropTarget! + */ + public static native boolean beginDragDropTarget(); /* + return ImPlot::BeginDragDropTarget(); + */ + + /** + * Turns the current plot's X-axis into a drag and drop target. Don't forget to call EndDragDropTarget! + */ + public static native boolean beginDragDropTargetX(); /* + return ImPlot::BeginDragDropTarget(); + */ + + /** + * Turns the current plot's Y-Axis into a drag and drop target. Don't forget to call EndDragDropTarget! + */ + public static native boolean beginDragDropTargetY(int yAxis); /* + return ImPlot::BeginDragDropTargetY(yAxis); + */ + + /** + * Turns the current plot's legend into a drag and drop target. Don't forget to call EndDragDropTarget! + */ + public static native boolean beginDragDropTargetLegend(); /* + return ImPlot::BeginDragDropTargetLegend(); + */ + + /** + * Ends a drag and drop target. + */ + public static native void endDragDropTarget(); /* + ImPlot::EndDragDropTarget(); + */ + + /** + * Turns the current plot's plotting area into a drag and drop source. Don't forget to call EndDragDropSource! + */ + public static native boolean beginDragDropSource(int keyMods, int dragDropFlags); /* + return ImPlot::BeginDragDropSource(keyMods, dragDropFlags); + */ + + /** + * Turns the current plot's X-axis into a drag and drop source. Don't forget to call EndDragDropSource! + */ + public static native boolean beginDragDropSourceX(int keyMods, int dragDropFlags); /* + return ImPlot::BeginDragDropSourceX(keyMods, dragDropFlags); + */ + + /** + * Turns the current plot's Y-axis into a drag and drop source. Don't forget to call EndDragDropSource! + */ + public static native boolean beginDragDropSourceY(int yAxis, int keyMods, int dragDropFlags); /* + return ImPlot::BeginDragDropSourceY(yAxis, keyMods, dragDropFlags); + */ + + /** + * Turns an item in the current plot's legend into drag and drop source. Don't forget to call EndDragDropSource! + */ + public static native boolean beginDragDropSourceItem(String labelID, int dragDropFlags); /* + return ImPlot::BeginDragDropSourceItem(labelID, dragDropFlags); + */ + + /** + * Ends a drag and drop source. + */ + public static native void endDragDropSource(); /* + ImPlot::EndDragDropSource(); + */ + + //----------------------------------------------------------------------------- + // Plot and Item Styling + //----------------------------------------------------------------------------- + + /** + * Provides access to plot style structure for permanant modifications to colors, sizes, etc. + */ + public static ImPlotStyle getStyle() { + IMPLOT_STYLE.ptr = nGetStyle(); + return IMPLOT_STYLE; + } + + private static native long nGetStyle(); /* + return (intptr_t)&ImPlot::GetStyle(); + */ + + /** + * Style plot colors for current ImGui style (default). + */ + public static native void styleColorsAuto(); /* + ImPlot::StyleColorsAuto(); + */ + + /** + * Style plot colors for ImGui "Classic". + */ + public static native void styleColorsClassic(); /* + ImPlot::StyleColorsClassic(); + */ + + /** + * Style plot colors for ImGui "Dark". + */ + public static native void styleColorsDark(); /* + ImPlot::StyleColorsDark(); + */ + + /** + * Style plot colors for ImGui "Light". + */ + public static native void styleColorsLight(); /* + ImPlot::StyleColorsLight(); + */ + + /** + * Temporarily modify a style color. Don't forget to call PopStyleColor! + */ + public static native void pushStyleColor(int idx, long col); /* + ImPlot::PushStyleColor(idx, col); + */ + + /** + * Temporarily modify a style color. Don't forget to call PopStyleColor! + */ + public static void pushStyleColor(final int idx, final ImVec4 col) { + nPushStyleColor(idx, col.w, col.x, col.y, col.z); + } + + private static native void nPushStyleColor(int idx, float w, float x, float y, float z); /* + ImPlot::PushStyleColor(idx, ImVec4(w, x, y, z)); + */ + + public static void popStyleColor() { + popStyleColor(1); + } + + public static native void popStyleColor(int count); /* + ImPlot::PopStyleColor(count); + */ + + /** + * Temporarily modify a style variable of float type. Don't forget to call PopStyleVar! + */ + public static native void pushStyleVar(int idx, float val); /* + ImPlot::PushStyleVar(idx, val); + */ + + /** + * Temporarily modify a style variable of int type. Don't forget to call PopStyleVar! + */ + public static native void pushStyleVar(int idx, int val); /* + ImPlot::PushStyleVar(idx, (int)val); + */ + + /** + * Temporarily modify a style variable of ImVec2 type. Don't forget to call PopStyleVar! + */ + public static void pushStyleVar(final int idx, final ImVec2 val) { + nPushStyleVar(idx, val.x, val.y); + } + + private static native void nPushStyleVar(int idx, float x, float y); /* + ImPlot::PushStyleVar(idx, ImVec2(x, y)); + */ + + /** + * Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count. + */ + public static void popStyleVar() { + popStyleVar(1); + } + + /** + * Undo temporary style variable modification(s). Undo multiple pushes at once by increasing count. + */ + public static native void popStyleVar(int count); /* + ImPlot::PopStyleVar(count); + */ + + /** + * Gets the last item primary color (i.e. its legend icon color) + */ + public static ImVec4 getLastItemColor() { + return new ImVec4(nGetLastItemColorS(0), nGetLastItemColorS(1), nGetLastItemColorS(2), nGetLastItemColorS(3)); + } + + private static native float nGetLastItemColorS(int selection); /* + if (selection == 0) + return ImPlot::GetLastItemColor().w; + else if (selection == 1) + return ImPlot::GetLastItemColor().x; + else if (selection == 2) + return ImPlot::GetLastItemColor().y; + else + return ImPlot::GetLastItemColor().z; + */ + + /** + * Returns the string name for an ImPlotCol. + */ + public static native String getStyleColorName(int idx); /* + return env->NewStringUTF(ImPlot::GetStyleColorName(idx)); + */ + + /** + * Returns the null terminated string name for an ImPlotMarker. + */ + public static native String getMarkerName(int idx); /* + return env->NewStringUTF(ImPlot::GetMarkerName(idx)); + */ + + //----------------------------------------------------------------------------- + // Colormaps + //----------------------------------------------------------------------------- + + /** + * 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! Colormaps are considered to be qualitative (i.e. discrete). + */ + public static int addColormap(final String name, final ImVec4[] cols) { + final float[] w = new float[cols.length]; + final float[] x = new float[cols.length]; + final float[] y = new float[cols.length]; + final float[] z = new float[cols.length]; + + for (int i = 0; i < cols.length; i++) { + w[i] = cols[i].w; + x[i] = cols[i].x; + y[i] = cols[i].y; + z[i] = cols[i].z; + } + + return nAddColormap(name, w, x, y, z, cols.length); + } + + private static native int nAddColormap(String name, float[] w, float[] x, float[] y, float[] z, int count); /* + ImVec4* cols = new ImVec4[count]; + for (int i = 0; i < count; i++) { + cols[i] = ImVec4(w[i], x[i], y[i], z[i]); + } + + return ImPlot::AddColormap(name, cols, count); + */ + + /** + * Returns the number of available colormaps (i.e. the built-in + user-added count). + */ + public static native int getColormapCount(); /* + return ImPlot::GetColormapCount(); + */ + + /** + * Returns a string name for a colormap given an index. + */ + public static native String getColormapName(int cmap); /* + return env->NewStringUTF(ImPlot::GetColormapName(cmap)); + */ + + /** + * Returns an index number for a colormap given a valid string name. Returns -1 if the name is invalid. + */ + public static native int getColormapIndex(String name); /* + return ImPlot::GetColormapIndex(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! + */ + public static native void pushColormap(int cmap); /* + ImPlot::PushColormap(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! + */ + public static native void pushColormap(String name); /* + ImPlot::PushColormap(name); + */ + + /** + * Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count. + */ + public static void popColormap() { + popColormap(1); + } + + /** + * Undo temporary colormap modification(s). Undo multiple pushes at once by increasing count. + */ + public static native void popColormap(int count); /* + ImPlot::PopColormap(count); + */ + + /** + * 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! + */ + public static ImVec4 nextColormapColor() { + final ImVec4 vec = new ImVec4(); + nNextColormapColor(vec); + return vec; + } + + private static native void nNextColormapColor(ImVec4 vec); /* + Jni::ImVec4Cpy(env, ImPlot::NextColormapColor(), vec); + */ + + /** + * Returns the size of a colormap. + */ + public static native int getColormapSize(int cmap); /* + return ImPlot::GetColormapSize(cmap); + */ + + /** + * Returns a color from a colormap given an index >= 0 (modulo will be performed). + */ + public static ImVec4 getColormapColor(final int idx, final int cmap) { + final ImVec4 vec = new ImVec4(); + nGetColormapColor(idx, cmap, vec); + return vec; + } + + private static native void nGetColormapColor(int idx, int cmap, ImVec4 vec); /* + Jni::ImVec4Cpy(env, ImPlot::GetColormapColor(idx, cmap), vec); + */ + + /** + * Sample a color from a colormap given t between 0 and 1 + */ + public static ImVec4 sampleColormap(final float t, final int cmap) { + final ImVec4 vec = new ImVec4(); + nSampleColormap(t, cmap, vec); + return vec; + } + + private static native void nSampleColormap(float t, int cmap, ImVec4 vec); /* + Jni::ImVec4Cpy(env, ImPlot::SampleColormap(t, cmap), vec); + */ + + /** + * Shows a vertical color scale with linear spaced ticks using the specified color map. Use double hashes to hide label (e.g. "##NoLabel"). + */ + public static native void colormapScale(String label, double scaleMin, double scaleMax, int cmap); /* + ImPlot::ColormapScale(label, scaleMin, scaleMax, ImVec2(0,0), cmap); + */ + + /** + * Shows a horizontal slider with a colormap gradient background. + */ + public static native boolean colormapSlider(String label, float t, int cmap); /* + return ImPlot::ColormapSlider(label, &t, NULL, "", cmap); + */ + + /** + * Shows a button with a colormap gradient brackground. + */ + public static native boolean colormapButton(String label, int cmap); /* + return ImPlot::ColormapButton(label, ImVec2(0,0), cmap); + */ + + /** + * 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). + */ + public static void bustColorCache() { + bustColorCache(null); + } + + /** + * 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). + */ + public static native void bustColorCache(String plotTableID); /* + ImPlot::BustColorCache(plotTableID); + */ + + //----------------------------------------------------------------------------- + // Miscellaneous + //----------------------------------------------------------------------------- + + /** + * Render icons similar to those that appear in legends (nifty for data lists). + */ + public static void itemIcon(final ImVec4 col) { + nItemIcon(col.w, col.x, col.y, col.z); + } + + private static native void nItemIcon(double a, double b, double c, double d); /* + ImPlot::ItemIcon(ImVec4(a, b, c, d)); + */ + + /** + * Render icons similar to those that appear in legends (nifty for data lists). + */ + public static native void colormapIcon(int colorMap); /* + ImPlot::ColormapIcon(colorMap); + */ + + /** + * Get the plot draw list for custom rendering to the current plot area. Call between Begin/EndPlot. + */ + public static ImDrawList getPlotDrawList() { + IM_DRAW_LIST.ptr = nGetPlotDrawList(); + return IM_DRAW_LIST; + } + + private static native long nGetPlotDrawList(); /* + return (intptr_t)ImPlot::GetPlotDrawList(); + */ + + /** + * Push clip rect for rendering to current plot area. The rect can be expanded or contracted by #expand pixels. Call between Begin/EndPlot. + */ + public static native void pushPlotClipRect(float expand); /* + ImPlot::PushPlotClipRect(expand); + */ + + /** + * Pop plot clip rect. Call between Begin/EndPlot. + */ + public static native void popPlotClipRect(); /* + ImPlot::PopPlotClipRect(); + */ + + /** + * Shows ImPlot style selector dropdown menu. + */ + public static native boolean showStyleSelector(String label); /* + return ImPlot::ShowStyleSelector(label); + */ + + /** + * Shows ImPlot colormap selector dropdown menu. + */ + public static native boolean showColormapSelector(String label); /* + return ImPlot::ShowColormapSelector(label); + */ + + /** + * Shows ImPlot style editor block (not a window). + */ + public static native void showStyleEditor(); /* + ImPlot::ShowStyleEditor(NULL); + */ + + /** + * Add basic help/info block for end users (not a window). + */ + public static native void showUserGuide(); /* + ImPlot::ShowUserGuide(); + */ + + /** + * Shows ImPlot metrics/debug information window. + */ + public static native void showMetricsWindow(); /* + ImPlot::ShowMetricsWindow(NULL); + */ + + //----------------------------------------------------------------------------- + // Demo + //----------------------------------------------------------------------------- + + /** + * Shows the ImPlot demo window. + */ + public static void showDemoWindow(final ImBoolean pOpen) { + nShowDemoWindow(pOpen.getData()); + } + + private static native void nShowDemoWindow(boolean[] pOpen); /* + ImPlot::ShowDemoWindow(&pOpen[0]); + */ +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlotContext.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotContext.java new file mode 100644 index 0000000..f33be96 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotContext.java @@ -0,0 +1,9 @@ +package imgui.extension.implot; + +import imgui.binding.ImGuiStruct; + +public final class ImPlotContext extends ImGuiStruct { + public ImPlotContext(final long ptr) { + super(ptr); + } +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlotLimits.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotLimits.java new file mode 100644 index 0000000..fcd2f6d --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotLimits.java @@ -0,0 +1,119 @@ +package imgui.extension.implot; + +import imgui.ImVec2; +import imgui.binding.ImGuiStructDestroyable; + +public final class ImPlotLimits extends ImGuiStructDestroyable { + public ImPlotLimits(final long ptr) { + super(ptr); + } + + public ImPlotLimits() { + this(0, 0, 0, 0); + } + + public ImPlotLimits(final double xMin, final double xMax, final double yMin, final double yMax) { + this(0); + ptr = create(xMin, xMax, yMin, yMax); + } + + /*JNI + #include "_common.h" + #include "_implot.h" + + #define IMPLOT_LIMITS ((ImPlotLimits*)STRUCT_PTR) + */ + + @Override + protected native long create(); /* + return (intptr_t)(new ImPlotLimits(0, 0, 0, 0)); + */ + + protected native long create(double xMin, double xMax, double yMin, double yMax); /* + return (intptr_t)(new ImPlotLimits(xMin, xMax, yMin, yMax)); + */ + + public boolean contains(final ImPlotPoint plotPoint) { + return contains(plotPoint.getX(), plotPoint.getY()); + } + + public native boolean contains(double x, double y); /* + return IMPLOT_LIMITS->Contains(x, y); + */ + + /** + * Returns the same as min(), but instead as an ImVec2. + */ + public ImVec2 minVec() { + final ImPlotPoint val = min(); + final ImVec2 vec = new ImVec2((float) val.getX(), (float) val.getY()); + val.destroy(); + return vec; + } + + /** + * The returned ImPlotPoint should be manually deallocated with destroy()! + */ + public ImPlotPoint min() { + return new ImPlotPoint(nMin()); + } + + private native long nMin(); /* + ImPlotPoint* p = new ImPlotPoint(IMPLOT_LIMITS->Min()); + return (intptr_t)p; + */ + + /** + * The returned ImPlotPoint should be manually deallocated with destroy()! + */ + public ImPlotPoint max() { + return new ImPlotPoint(nMax()); + } + + /** + * Returns the same as max(), but instead as an ImVec2. + */ + public ImVec2 maxVec() { + final ImPlotPoint val = max(); + final ImVec2 vec = new ImVec2((float) val.getX(), (float) val.getY()); + val.destroy(); + return vec; + } + + private native long nMax(); /* + ImPlotPoint* p = new ImPlotPoint(IMPLOT_LIMITS->Max()); + return (intptr_t)p; + */ + + public ImPlotRange getX() { + return new ImPlotRange(nGetX(this.ptr)); + } + + private native long nGetX(long ptr); /* + return (intptr_t)&(IMPLOT_LIMITS->X); + */ + + public ImPlotRange getY() { + return new ImPlotRange(nGetY(this.ptr)); + } + + private native long nGetY(long ptr); /* + return (intptr_t)&(IMPLOT_LIMITS->Y); + */ + + public void setX(final ImPlotRange value) { + nSetX(value.ptr); + } + + private native void nSetX(long valueptr); /* + IMPLOT_LIMITS->X = *((ImPlotRange*)valueptr); + */ + + public void setY(final ImPlotRange value) { + nSetY(value.ptr); + } + + private native void nSetY(long valueptr); /* + IMPLOT_LIMITS->Y = *((ImPlotRange*)valueptr); + */ +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlotPoint.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotPoint.java new file mode 100644 index 0000000..bebc36f --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotPoint.java @@ -0,0 +1,55 @@ +package imgui.extension.implot; + +import imgui.ImVec2; +import imgui.binding.ImGuiStructDestroyable; + +public final class ImPlotPoint extends ImGuiStructDestroyable { + public ImPlotPoint(final long ptr) { + super(ptr); + } + + public ImPlotPoint() { + this(0, 0); + } + + public ImPlotPoint(final ImVec2 vec) { + this(vec.x, vec.y); + } + + public ImPlotPoint(final double x, final double y) { + this(0); + ptr = create(x, y); + } + + /*JNI + #include "_common.h" + #include "_implot.h" + + #define IMPLOT_POINT ((ImPlotPoint*)STRUCT_PTR) + */ + + @Override + protected native long create(); /* + return (intptr_t)(new ImPlotPoint(0, 0)); + */ + + protected native long create(double x, double y); /* + return (intptr_t)(new ImPlotPoint(x, y)); + */ + + public native double getX(); /* + return IMPLOT_POINT->x; + */ + + public native double getY(); /* + return IMPLOT_POINT->y; + */ + + public native void setX(double value); /* + IMPLOT_POINT->x = value; + */ + + public native void setY(double value); /* + IMPLOT_POINT->y = value; + */ +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlotRange.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotRange.java new file mode 100644 index 0000000..d242a17 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotRange.java @@ -0,0 +1,58 @@ +package imgui.extension.implot; + +import imgui.binding.ImGuiStructDestroyable; + +public final class ImPlotRange extends ImGuiStructDestroyable { + public ImPlotRange(final long ptr) { + super(ptr); + } + + public ImPlotRange() { + this(0, 0); + } + + public ImPlotRange(final double min, final double max) { + this(0); + ptr = create(min, max); + } + + /*JNI + #include "_common.h" + #include "_implot.h" + + #define IMPLOT_RANGE ((ImPlotRange*)STRUCT_PTR) + */ + + @Override + protected native long create(); /* + return (intptr_t)(new ImPlotRange(0, 0)); + */ + + protected native long create(double min, double max); /* + return (intptr_t)(new ImPlotRange(min, max)); + */ + + public native boolean contains(double value); /* + return IMPLOT_RANGE->Contains(value); + */ + + public native double size(); /* + return IMPLOT_RANGE->Size(); + */ + + public native double getMin(); /* + return IMPLOT_RANGE->Min; + */ + + public native double getMax(); /* + return IMPLOT_RANGE->Max; + */ + + public native void setMin(double min); /* + IMPLOT_RANGE->Min = min; + */ + + public native void nSetMax(double max); /* + IMPLOT_RANGE->Max = max; + */ +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/ImPlotStyle.java b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotStyle.java new file mode 100644 index 0000000..0471b77 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/ImPlotStyle.java @@ -0,0 +1,525 @@ +package imgui.extension.implot; + +import imgui.ImVec2; +import imgui.ImVec4; +import imgui.binding.ImGuiStruct; +import imgui.extension.implot.flag.ImPlotCol; + +public final class ImPlotStyle extends ImGuiStruct { + public ImPlotStyle(final long ptr) { + super(ptr); + } + + /*JNI + #include "_common.h" + #include "_implot.h" + + #define IMPLOT_STYLE ((ImPlotStyle*)STRUCT_PTR) + */ + + //Line weight + public native float getLineWeight(); /* + return IMPLOT_STYLE->LineWeight; + */ + + public native void setLineWeight(float lineWeight); /* + IMPLOT_STYLE->LineWeight = lineWeight; + */ + + //Marker + public native int getMarker(); /* + return IMPLOT_STYLE->Marker; + */ + + public native void setMarker(float input); /* + IMPLOT_STYLE->Marker = input; + */ + + //Marker size + public native float getMarkerSize(); /* + return IMPLOT_STYLE->MarkerSize; + */ + + public native void setMarkerSize(float input); /* + IMPLOT_STYLE->MarkerSize = input; + */ + + //Marker weight + public native float getMarkerWeight(); /* + return IMPLOT_STYLE->MarkerWeight; + */ + + public native void setMarkerWeight(float input); /* + IMPLOT_STYLE->MarkerWeight = input; + */ + + //Fill alpha + public native float getFillAlpha(); /* + return IMPLOT_STYLE->FillAlpha; + */ + + public native void setFillAlpha(float input); /* + IMPLOT_STYLE->FillAlpha = input; + */ + + //Error bar size + public native float getErrorBarSize(); /* + return IMPLOT_STYLE->ErrorBarSize; + */ + + public native void setErrorBarSize(float input); /* + IMPLOT_STYLE->ErrorBarSize = input; + */ + + //Error bar weight + public native float getErrorBarWeight(); /* + return IMPLOT_STYLE->ErrorBarWeight; + */ + + public native void setErrorBarWeight(float input); /* + IMPLOT_STYLE->ErrorBarWeight = input; + */ + + //Digital big height + public native float getDigitalBitHeight(); /* + return IMPLOT_STYLE->DigitalBitHeight; + */ + + public native void setDigitalBitHeight(float input); /* + IMPLOT_STYLE->DigitalBitHeight = input; + */ + + //Digital bit gap + public native float getDigitalBitGap(); /* + return IMPLOT_STYLE->DigitalBitGap; + */ + + public native void setDigitalBitGap(float input); /* + IMPLOT_STYLE->DigitalBitGap = input; + */ + + //Plot border size + public native float getPlotBorderSize(); /* + return IMPLOT_STYLE->PlotBorderSize; + */ + + public native void setPlotBorderSize(float input); /* + IMPLOT_STYLE->PlotBorderSize = input; + */ + + //Minor alpha + public native float getMinorAlpha(); /* + return IMPLOT_STYLE->MinorAlpha; + */ + + public native void setMinorAlpha(float input); /* + IMPLOT_STYLE->MinorAlpha = input; + */ + + //Major tick length + public ImVec2 getMajorTickLen() { + final ImVec2 vec = new ImVec2(); + nGetMajorTickLen(vec); + return vec; + } + + private native void nGetMajorTickLen(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MajorTickLen, vec); + */ + + public void setMajorTickLen(final ImVec2 majorTickLen) { + nSetMajorTickLen(majorTickLen.x, majorTickLen.y); + } + + private native void nSetMajorTickLen(float x, float y); /* + IMPLOT_STYLE->MajorTickLen = ImVec2(x, y); + */ + + //Minor tick length + public ImVec2 getMinorTickLen() { + final ImVec2 vec = new ImVec2(); + nGetMinorTickLen(vec); + return vec; + } + + private native void nGetMinorTickLen(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MinorTickLen, vec); + */ + + public void setMinorTickLen(final ImVec2 minorTickLen) { + nSetMinorTickLen(minorTickLen.x, minorTickLen.y); + } + + private native void nSetMinorTickLen(float x, float y); /* + IMPLOT_STYLE->MinorTickLen = ImVec2(x, y); + */ + + //Major tick size + public ImVec2 getMajorTickSize() { + final ImVec2 vec = new ImVec2(); + nGetMajorTickSize(vec); + return vec; + } + + private native void nGetMajorTickSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MajorTickSize, vec); + */ + + public void setMajorTickSize(final ImVec2 majorTickSize) { + nSetMajorTickSize(majorTickSize.x, majorTickSize.y); + } + + private native void nSetMajorTickSize(float x, float y); /* + IMPLOT_STYLE->MajorTickSize = ImVec2(x, y); + */ + + //Minor tick size + public ImVec2 getMinorTickSize() { + final ImVec2 vec = new ImVec2(); + nGetMinorTickSize(vec); + return vec; + } + + private native void nGetMinorTickSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MinorTickSize, vec); + */ + + public void setMinorTickSize(final ImVec2 minorTickSize) { + nSetMinorTickSize(minorTickSize.x, minorTickSize.y); + } + + private native void nSetMinorTickSize(float x, float y); /* + IMPLOT_STYLE->MinorTickSize = ImVec2(x, y); + */ + + //Major grid size + public ImVec2 getMajorGridSize() { + final ImVec2 vec = new ImVec2(); + nGetMajorGridSize(vec); + return vec; + } + + private native void nGetMajorGridSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MajorGridSize, vec); + */ + + public void setMajorGridSize(final ImVec2 majorGridSize) { + nSetMajorGridSize(majorGridSize.x, majorGridSize.y); + } + + private native void nSetMajorGridSize(float x, float y); /* + IMPLOT_STYLE->MajorGridSize = ImVec2(x, y); + */ + + //Minor grid size + public ImVec2 getMinorGridSize() { + final ImVec2 vec = new ImVec2(); + nGetMinorGridSize(vec); + return vec; + } + + private native void nGetMinorGridSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MinorGridSize, vec); + */ + + public void setMinorGridSize(final ImVec2 minorGridSize) { + nSetMinorGridSize(minorGridSize.x, minorGridSize.y); + } + + private native void nSetMinorGridSize(float x, float y); /* + IMPLOT_STYLE->MinorGridSize = ImVec2(x, y); + */ + + //Plot padding + public ImVec2 getPlotPadding() { + final ImVec2 vec = new ImVec2(); + nGetPlotPadding(vec); + return vec; + } + + private native void nGetPlotPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->PlotPadding, vec); + */ + + public void setPlotPadding(final ImVec2 plotPadding) { + nSetPlotPadding(plotPadding.x, plotPadding.y); + } + + private native void nSetPlotPadding(float x, float y); /* + IMPLOT_STYLE->PlotPadding = ImVec2(x, y); + */ + + //Label padding + public ImVec2 getLabelPadding() { + final ImVec2 vec = new ImVec2(); + nGetLabelPadding(vec); + return vec; + } + + private native void nGetLabelPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->LabelPadding, vec); + */ + + public void setLabelPadding(final ImVec2 labelPadding) { + nSetLabelPadding(labelPadding.x, labelPadding.y); + } + + private native void nSetLabelPadding(float x, float y); /* + IMPLOT_STYLE->LabelPadding = ImVec2(x, y); + */ + + //Legend padding + public ImVec2 getLegendPadding() { + final ImVec2 vec = new ImVec2(); + nGetLegendPadding(vec); + return vec; + } + + private native void nGetLegendPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->LegendPadding, vec); + */ + + public void setLegendPadding(final ImVec2 legendPadding) { + nSetLegendPadding(legendPadding.x, legendPadding.y); + } + + private native void nSetLegendPadding(float x, float y); /* + IMPLOT_STYLE->LegendPadding = ImVec2(x, y); + */ + + //Legend inner padding + public ImVec2 getLegendInnerPadding() { + final ImVec2 vec = new ImVec2(); + nGetLegendInnerPadding(vec); + return vec; + } + + private native void nGetLegendInnerPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->LegendInnerPadding, vec); + */ + + public void setLegendInnerPadding(final ImVec2 legendInnerPadding) { + nSetLegendInnerPadding(legendInnerPadding.x, legendInnerPadding.y); + } + + private native void nSetLegendInnerPadding(float x, float y); /* + IMPLOT_STYLE->LegendInnerPadding = ImVec2(x, y); + */ + + //Legend spacing + public ImVec2 getLegendSpacing() { + final ImVec2 vec = new ImVec2(); + nGetLegendSpacing(vec); + return vec; + } + + private native void nGetLegendSpacing(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->LegendSpacing, vec); + */ + + public void setLegendSpacing(final ImVec2 legendSpacing) { + nSetLegendSpacing(legendSpacing.x, legendSpacing.y); + } + + private native void nSetLegendSpacing(float x, float y); /* + IMPLOT_STYLE->LegendSpacing = ImVec2(x, y); + */ + + //Mouse position padding + public ImVec2 getMousePosPadding() { + final ImVec2 vec = new ImVec2(); + nGetMousePosPadding(vec); + return vec; + } + + private native void nGetMousePosPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->MousePosPadding, vec); + */ + + public void setMousePosPadding(final ImVec2 mousePosPadding) { + nSetMousePosPadding(mousePosPadding.x, mousePosPadding.y); + } + + private native void nSetMousePosPadding(float x, float y); /* + IMPLOT_STYLE->MousePosPadding = ImVec2(x, y); + */ + + //Annotation padding + public ImVec2 getAnnotationPadding() { + final ImVec2 vec = new ImVec2(); + nGetAnnotationPadding(vec); + return vec; + } + + private native void nGetAnnotationPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->AnnotationPadding, vec); + */ + + public void setAnnotationPadding(final ImVec2 annotationPadding) { + nSetAnnotationPadding(annotationPadding.x, annotationPadding.y); + } + + private native void nSetAnnotationPadding(float x, float y); /* + IMPLOT_STYLE->AnnotationPadding = ImVec2(x, y); + */ + + //Fit padding + public ImVec2 getFitPadding() { + final ImVec2 vec = new ImVec2(); + nGetFitPadding(vec); + return vec; + } + + private native void nGetFitPadding(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->FitPadding, vec); + */ + + public void setFitPadding(final ImVec2 fitPadding) { + nSetFitPadding(fitPadding.x, fitPadding.y); + } + + private native void nSetFitPadding(float x, float y); /* + IMPLOT_STYLE->FitPadding = ImVec2(x, y); + */ + + //Plot default size + public ImVec2 getPlotDefaultSize() { + final ImVec2 vec = new ImVec2(); + nGetPlotDefaultSize(vec); + return vec; + } + + private native void nGetPlotDefaultSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->PlotDefaultSize, vec); + */ + + public void setPlotDefaultSize(final ImVec2 plotDefaultSize) { + nSetPlotDefaultSize(plotDefaultSize.x, plotDefaultSize.y); + } + + private native void nSetPlotDefaultSize(float x, float y); /* + IMPLOT_STYLE->PlotDefaultSize = ImVec2(x, y); + */ + + //Plot minimum size + public ImVec2 getPlotMinSize() { + final ImVec2 vec = new ImVec2(); + nGetPlotMinSize(vec); + return vec; + } + + private native void nGetPlotMinSize(ImVec2 vec); /* + Jni::ImVec2Cpy(env, IMPLOT_STYLE->PlotMinSize, vec); + */ + + public void setPlotMinSize(final ImVec2 plotMinSize) { + nSetPlotMinSize(plotMinSize.x, plotMinSize.y); + } + + private native void nSetPlotMinSize(float x, float y); /* + IMPLOT_STYLE->PlotMinSize = ImVec2(x, y); + */ + + //Colors + public ImVec4[] getColors() { + final float[] w = new float[ImPlotCol.COUNT]; + final float[] x = new float[ImPlotCol.COUNT]; + final float[] y = new float[ImPlotCol.COUNT]; + final float[] z = new float[ImPlotCol.COUNT]; + + nGetColors(w, x, y, z, ImPlotCol.COUNT); + + final ImVec4[] colors = new ImVec4[ImPlotCol.COUNT]; + for (int i = 0; i < ImPlotCol.COUNT; i++) { + colors[i] = new ImVec4(w[i], x[i], y[i], z[i]); + } + return colors; + } + + private native void nGetColors(float[] w, float[] x, float[] y, float[] z, int count); /* + ImVec4* colors = IMPLOT_STYLE->Colors; + + for (int i = 0; i < count; i++) { + w[i] = colors->w; + x[i] = colors->x; + y[i] = colors->y; + z[i] = colors->z; + + colors++; + } + */ + + public void setColors(final ImVec4[] colors) { + final float[] w = new float[ImPlotCol.COUNT]; + final float[] x = new float[ImPlotCol.COUNT]; + final float[] y = new float[ImPlotCol.COUNT]; + final float[] z = new float[ImPlotCol.COUNT]; + + for (int i = 0; i < ImPlotCol.COUNT; i++) { + w[i] = colors[i].w; + x[i] = colors[i].x; + y[i] = colors[i].y; + z[i] = colors[i].z; + } + + nSetColors(w, x, y, z, ImPlotCol.COUNT); + } + + private native void nSetColors(float[] w, float[] x, float[] y, float[] z, int count); /* + ImVec4* colors = IMPLOT_STYLE->Colors; + + for (int i = 0; i < count; i++) { + colors->w = w[i]; + colors->x = x[i]; + colors->y = y[i]; + colors->z = z[i]; + + colors++; + } + */ + + //Colormap + public native int getColormap(); /* + return IMPLOT_STYLE->Colormap; + */ + + public native void setColormap(int input); /* + IMPLOT_STYLE->Colormap = input; + */ + + //Antialiasing + public native boolean isAntiAliasedLines(); /* + return IMPLOT_STYLE->AntiAliasedLines; + */ + + public native void setAntiAliasedLines(boolean input); /* + IMPLOT_STYLE->AntiAliasedLines = input; + */ + + //Local time + public native boolean isUseLocalTime(); /* + return IMPLOT_STYLE->UseLocalTime; + */ + + public native void setUseLocalTime(boolean input); /* + IMPLOT_STYLE->UseLocalTime = input; + */ + + //ISO 8601 + public native boolean isUseISO8601(); /* + return IMPLOT_STYLE->UseISO8601; + */ + + public native void setUseISO8601(boolean input); /* + IMPLOT_STYLE->UseISO8601 = input; + */ + + //24HR clock + public native boolean isUse24HourClock(); /* + return IMPLOT_STYLE->Use24HourClock; + */ + + public native void setUse24HourClock(boolean input); /* + IMPLOT_STYLE->Use24HourClock = input; + */ +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotAxisFlags.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotAxisFlags.java new file mode 100644 index 0000000..9fddd1a --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotAxisFlags.java @@ -0,0 +1,37 @@ +package imgui.extension.implot.flag; + +public final class ImPlotAxisFlags { + private ImPlotAxisFlags() { + } + + /** default */ + public static final int None = 0; + /** the axis label will not be displayed (axis labels also hidden if the supplied string name is NULL) */ + public static final int NoLabel = 1; + /** no grid lines will be displayed */ + public static final int NoGridLines = 1 << 1; + /** no tick marks will be displayed */ + public static final int NoTickMarks = 1 << 2; + /** no text labels will be displayed */ + public static final int NoTickLabels = 1 << 3; + /** grid lines will be displayed in the foreground (i.e. on top of data) in stead of the background */ + public static final int Foreground = 1 << 4; + /** a logartithmic (base 10) axis scale will be used (mutually exclusive with ImPlotAxisFlags_Time) */ + public static final int LogScale = 1 << 5; + /** axis will display date/time formatted labels (mutually exclusive with ImPlotAxisFlags_LogScale) */ + public static final int Time = 1 << 6; + /** the axis will be inverted */ + public static final int Invert = 1 << 7; + /** axis will not be initially fit to data extents on the first rendered frame (also the case if SetNextPlotLimits explicitly called) */ + public static final int NoInitialFit = 1 << 8; + /** axis will be auto-fitting to data extents */ + public static final int AutoFit = 1 << 9; + /** axis will only fit points if the point is in the visible range of the **orthoganol** axis */ + public static final int RangeFit = 1 << 10; + /** the axis minimum value will be locked when panning/zooming */ + public static final int LockMin = 1 << 11; + /** the axis maximum value will be locked when panning/zooming */ + public static final int LockMax = 1 << 12; + public static final int Lock = LockMin | LockMax; + public static final int NoDecorations = NoLabel | NoGridLines | NoTickMarks | NoTickLabels; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotBin.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotBin.java new file mode 100644 index 0000000..89f0383 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotBin.java @@ -0,0 +1,15 @@ +package imgui.extension.implot.flag; + +public final class ImPlotBin { + private ImPlotBin() { + } + + /** k = sqrt(n) */ + public static final int Sqrt = -1; + /** k = 1 + log2(n) */ + public static final int Sturges = -2; + /** k = 2 * cbrt(n) */ + public static final int Rice = -3; + /** w = 3.49 * sigma / cbrt(n) */ + public static final int Scott = -4; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotCol.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotCol.java new file mode 100644 index 0000000..b8a0779 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotCol.java @@ -0,0 +1,57 @@ +package imgui.extension.implot.flag; + +public final class ImPlotCol { + private ImPlotCol() { + } + + /** plot line/outline color (defaults to next unused color in current colormap)*/ + public static final int Line = 0; + /** plot fill color for bars (defaults to the current line color)*/ + public static final int Fill = 1; + /** marker outline color (defaults to the current line color)*/ + public static final int MarkerOutline = 2; + /** marker fill color (defaults to the current line color)*/ + public static final int MarkerFill = 3; + /** error bar color (defaults to ImGuiCol_Text)*/ + public static final int ErrorBar = 4; + // plot styling colors + /** plot frame background color (defaults to ImGuiCol_FrameBg) */ + public static final int FrameBg = 5; + /** plot area background color (defaults to ImGuiCol_WindowBg) */ + public static final int PlotBg = 6; + /** plot area border color (defaults to ImGuiCol_Border) */ + public static final int PlotBorder = 7; + /** legend background color (defaults to ImGuiCol_PopupBg) */ + public static final int LegendBg = 8; + /** legend border color (defaults to ImPlotCol_PlotBorder) */ + public static final int LegendBorder = 9; + /** legend text color (defaults to ImPlotCol_InlayText) */ + public static final int LegendText = 10; + /** plot title text color (defaults to ImGuiCol_Text) */ + public static final int TitleText = 11; + /** color of text appearing inside of plots (defaults to ImGuiCol_Text) */ + public static final int InlayText = 12; + /** x-axis label and tick lables color (defaults to ImGuiCol_Text) */ + public static final int XAxis = 13; + /** x-axis grid color (defaults to 25% ImPlotCol_XAxis) */ + public static final int XAxisGrid = 14; + /** y-axis label and tick labels color (defaults to ImGuiCol_Text) */ + public static final int YAxis = 15; + /** y-axis grid color (defaults to 25% ImPlotCol_YAxis) */ + public static final int YAxisGrid = 16; + /** 2nd y-axis label and tick labels color (defaults to ImGuiCol_Text) */ + public static final int YAxis2 = 17; + /** 2nd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis2) */ + public static final int YAxisGrid2 = 18; + /** 3rd y-axis label and tick labels color (defaults to ImGuiCol_Text) */ + public static final int YAxis3 = 19; + /** 3rd y-axis grid/label color (defaults to 25% ImPlotCol_YAxis3) */ + public static final int YAxisGrid3 = 21; + /** box-selection color (defaults to yellow) */ + public static final int Selection = 22; + /** box-query color (defaults to green) */ + public static final int Query = 23; + /** crosshairs color (defaults to ImPlotCol_PlotBorder) */ + public static final int Crosshairs = 24; + public static final int COUNT = 25; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotColormap.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotColormap.java new file mode 100644 index 0000000..709f43c --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotColormap.java @@ -0,0 +1,39 @@ +package imgui.extension.implot.flag; + +public final class ImPlotColormap { + private ImPlotColormap() { + } + + /** a.k.a. seaborn deep (qual=true, n=10) (default) */ + public static final int Deep = 0; + /** a.k.a. matplotlib "Set1" (qual=true, n=9 ) */ + public static final int Dark = 1; + /** a.k.a. matplotlib "Pastel1" (qual=true, n=9 ) */ + public static final int Pastel = 2; + /** a.k.a. matplotlib "Paired" (qual=true, n=12) */ + public static final int Paired = 3; + /** a.k.a. matplotlib "viridis" (qual=false, n=11) */ + public static final int Viridis = 4; + /** a.k.a. matplotlib "plasma" (qual=false, n=11) */ + public static final int Plasma = 5; + /** a.k.a. matplotlib/MATLAB "hot" (qual=false, n=11) */ + public static final int Hot = 6; + /** a.k.a. matplotlib/MATLAB "cool" (qual=false, n=11) */ + public static final int Cool = 7; + /** a.k.a. matplotlib/MATLAB "pink" (qual=false, n=11) */ + public static final int Pink = 8; + /** a.k.a. MATLAB "jet" (qual=false, n=11) */ + public static final int Jet = 9; + /** a.k.a. matplotlib "twilight" (qual=false, n=11) */ + public static final int Twilight = 10; + /** red/blue, Color Brewer (qual=false, n=11) */ + public static final int RdBu = 11; + /** brown/blue-green, Color Brewer (qual=false, n=11) */ + public static final int BrBG = 12; + /** pink/yellow-green, Color Brewer (qual=false, n=11) */ + public static final int PiYG = 13; + /** color spectrum, Color Brewer (qual=false, n=11) */ + public static final int Spectral = 14; + /** white/black (qual=false, n=2 ) */ + public static final int Greys = 15; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotFlags.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotFlags.java new file mode 100644 index 0000000..33390b6 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotFlags.java @@ -0,0 +1,36 @@ +package imgui.extension.implot.flag; + +public final class ImPlotFlags { + private ImPlotFlags() { + } + + /** default */ + public static final int None = 0; + /** the plot title will not be displayed (titles are also hidden if preceeded by double hashes, e.g. "##MyPlot") */ + public static final int NoTitle = 1; + /** the legend will not be displayed */ + public static final int NoLegend = 1 << 1; + /** the user will not be able to open context menus with right-click */ + public static final int NoMenus = 1 << 2; + /** the user will not be able to box-select with right-click drag */ + public static final int NoBoxSelect = 1 << 3; + /** the mouse position, in plot coordinates, will not be displayed inside of the plot */ + public static final int NoMousePos = 1 << 4; + /** plot items will not be highlighted when their legend entry is hovered */ + public static final int NoHighlight = 1 << 5; + /** a child window region will not be used to capture mouse scroll (can boost performance for single ImGui window applications) */ + public static final int NoChild = 1 << 6; + /** primary x and y axes will be constrained to have the same units/pixel (does not apply to auxiliary y-axes) */ + public static final int Equal = 1 << 7; + /** enable a 2nd y-axis on the right side */ + public static final int YAxis2 = 1 << 8; + /** enable a 3rd y-axis on the right side */ + public static final int YAxis3 = 1 << 9; + /** the user will be able to draw query rects with middle-mouse or CTRL + right-click drag */ + public static final int Query = 1 << 1; + /** the default mouse cursor will be replaced with a crosshair when hovered */ + public static final int Crosshairs = 1 << 1; + /** plot lines will be software anti-aliased (not recommended for high density plots, prefer MSAA) */ + public static final int AntiAliased = 1 << 1; + public static final int CanvasOnly = NoTitle | NoLegend | NoMenus | NoBoxSelect | NoMousePos; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotLocation.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotLocation.java new file mode 100644 index 0000000..40d820e --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotLocation.java @@ -0,0 +1,25 @@ +package imgui.extension.implot.flag; + +public final class ImPlotLocation { + private ImPlotLocation() { + } + + /** center-center */ + public static final int Center = 0; + /** top-center */ + public static final int North = 1; + /** bottom-center */ + public static final int South = 1 << 1; + /** center-left */ + public static final int West = 1 << 2; + /** center-right */ + public static final int East = 1 << 3; + /** top-left */ + public static final int NorthWest = North | West; + /** top-right */ + public static final int NorthEast = North | East; + /** bottom-left */ + public static final int SouthWest = South | West; + /** bottom-right */ + public static final int SouthEast = South | East; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotMarker.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotMarker.java new file mode 100644 index 0000000..04800c7 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotMarker.java @@ -0,0 +1,30 @@ +package imgui.extension.implot.flag; + +public final class ImPlotMarker { + private ImPlotMarker() { + } + + /** no marker */ + public static final int None = -1; + /** a circle marker */ + public static final int Circle = 0; + /** a square maker */ + public static final int Square = 1; + /** a diamond marker */ + public static final int Diamond = 2; + /** an upward-pointing triangle marker */ + public static final int Up = 3; + /** an downward-pointing triangle marker */ + public static final int Down = 4; + /** an leftward-pointing triangle marker */ + public static final int Left = 5; + /** an rightward-pointing triangle marker */ + public static final int Right = 6; + /** a cross marker (not fillable) */ + public static final int Cross = 7; + /** a plus marker (not fillable) */ + public static final int Plus = 8; + /** a asterisk marker (not fillable) */ + public static final int Asterisk = 9; + public static final int COUNT = 10; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotOrientation.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotOrientation.java new file mode 100644 index 0000000..edc07bb --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotOrientation.java @@ -0,0 +1,11 @@ +package imgui.extension.implot.flag; + +public final class ImPlotOrientation { + private ImPlotOrientation() { + } + + /** left/right */ + public static final int Horizontal = 0; + /** up/down */ + public static final int Vertical = 1; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotStyleVar.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotStyleVar.java new file mode 100644 index 0000000..95dba55 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotStyleVar.java @@ -0,0 +1,62 @@ +package imgui.extension.implot.flag; + +public final class ImPlotStyleVar { + private ImPlotStyleVar() { + } + + /** float, plot item line weight in pixels */ + public static final int LineWeight = 0; + /** int, marker specification */ + public static final int Marker = 1; + /** float, marker size in pixels (roughly the marker's "radius") */ + public static final int MarkerSize = 2; + /** float, plot outline weight of markers in pixels */ + public static final int MarkerWeight = 3; + /** float, alpha modifier applied to all plot item fills */ + public static final int FillAlpha = 4; + /** float, error bar whisker width in pixels */ + public static final int ErrorBarSize = 5; + /** float, error bar whisker weight in pixels */ + public static final int ErrorBarWeight = 6; + /** float, digital channels bit height (at 1) in pixels */ + public static final int DigitalBitHeight = 7; + /** float, digital channels bit padding gap in pixels */ + public static final int DigitalBitGap = 8; + /** float, thickness of border around plot area */ + public static final int PlotBorderSize = 9; + /** float, alpha multiplier applied to minor axis grid lines */ + public static final int MinorAlpha = 10; + /** ImVec2, major tick lengths for X and Y axes */ + public static final int MajorTickLen = 12; + /** ImVec2, minor tick lengths for X and Y axes */ + public static final int MinorTickLen = 13; + /** ImVec2, line thickness of major ticks */ + public static final int MajorTickSize = 14; + /** ImVec2, line thickness of minor ticks */ + public static final int MinorTickSize = 15; + /** ImVec2, line thickness of major grid lines */ + public static final int MajorGridSize = 16; + /** ImVec2, line thickness of minor grid lines */ + public static final int MinorGridSize = 17; + /** ImVec2, padding between widget frame and plot area, labels, or outside legends (i.e. main padding) */ + public static final int PlotPadding = 18; + /** ImVec2, padding between axes labels, tick labels, and plot edge */ + public static final int LabelPadding = 19; + /** ImVec2, legend padding from plot edges */ + public static final int LegendPadding = 20; + /** ImVec2, legend inner padding from legend edges */ + public static final int LegendInnerPadding = 21; + /** ImVec2, spacing between legend entries */ + public static final int LegendSpacing = 22; + /** ImVec2, padding between plot edge and interior info text */ + public static final int MousePosPadding = 23; + /** ImVec2, text padding around annotation labels */ + public static final int AnnotationPadding = 24; + /** 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) */ + public static final int FitPadding = 25; + /** ImVec2, default size used when ImVec2(0,0) is passed to BeginPlot */ + public static final int PlotDefaultSize = 26; + /** ImVec2, minimum size plot frame can be when shrunk */ + public static final int PlotMinSize = 27; + public static final int COUNT = 28; +} diff --git a/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotYAxis.java b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotYAxis.java new file mode 100644 index 0000000..a1cea8f --- /dev/null +++ b/imgui-binding/src/main/java/imgui/extension/implot/flag/ImPlotYAxis.java @@ -0,0 +1,13 @@ +package imgui.extension.implot.flag; + +public final class ImPlotYAxis { + private ImPlotYAxis() { + } + + /** left (default) */ + public static final int YAxis_1 = 0; + /** first on right side */ + public static final int YAxis_2 = 1; + /** second on right side */ + public static final int YAxis_3 = 2; +} diff --git a/imgui-binding/src/main/native/_implot.h b/imgui-binding/src/main/native/_implot.h new file mode 100644 index 0000000..5f7dfb7 --- /dev/null +++ b/imgui-binding/src/main/native/_implot.h @@ -0,0 +1,6 @@ +#pragma once + +#include "_base.h" +#include "_binding.h" +#include +#include "implot.h" diff --git a/include/implot b/include/implot new file mode 160000 index 0000000..555ff68 --- /dev/null +++ b/include/implot @@ -0,0 +1 @@ +Subproject commit 555ff688a8134bc0c602123149abe9c17d577475