[API] Add API for Dear ImGui v1.78

README.md

@@ -225,7 +225,7 @@ If you're using native libs directly, you'll need to provide a VM option: `imgui
 **You are ready to use imgui-java binding!**
 
 ## Using Multi-Viewports and Docking
-Binding based on the Dear ImGui [docking](https://github.com/ocornut/imgui/tree/docking) branch, commit: [90ea7e2f2f3c4096a58b8bd14c274d80ae63e1ce](https://github.com/ocornut/imgui/tree/90ea7e2f2f3c4096a58b8bd14c274d80ae63e1ce).
+Binding based on the Dear ImGui [docking](https://github.com/ocornut/imgui/tree/docking) branch, commit: [05bc204dbd80dfebb3dab1511caf1cb980620c76](https://github.com/ocornut/imgui/tree/05bc204dbd80dfebb3dab1511caf1cb980620c76).
 That branch contains two important features: [multi-viewports](https://github.com/ocornut/imgui/issues/1542) and [docking](https://github.com/ocornut/imgui/issues/2109).
 See an official documentation about how to work with them.
 

imgui-binding/src/main/java/imgui/ImDrawList.java

@@ -123,6 +123,7 @@ public final class ImDrawList extends ImGuiStruct {
     // Primitives
     // - For rectangular primitives, "pMin" and "pMax" represent the upper-left and lower-right corners.
     // - For circle primitives, use "num_segments == 0" to automatically calculate tessellation (preferred).
+    //   In older versions (until Dear ImGui 1.77) the AddCircle functions defaulted to num_segments == 12.
     //   In future versions we will use textures to provide cheaper and higher-quality circles.
     //   Use AddNgon() and AddNgonFilled() functions if you need to guaranteed a specific number of sides.
 

imgui-binding/src/main/java/imgui/ImGui.java

@@ -868,14 +868,14 @@ public final class ImGui {
     */
 
     /**
-     * Get maximum scrolling amount ~~ ContentSize.X - WindowSize.X
+     * Get maximum scrolling amount ~~ ContentSize.x - WindowSize.x
      */
     public static native float getScrollMaxX(); /*
         return ImGui::GetScrollMaxX();
     */
 
     /**
-     * Get maximum scrolling amount ~~ ContentSize.Y - WindowSize.Y
+     * Get maximum scrolling amount ~~ ContentSize.y - WindowSize.y
      */
     public static native float getScrollMaxY(); /*
         return ImGui::GetScrollMaxY();
@@ -1548,12 +1548,19 @@ public final class ImGui {
     */
 
     /**
-     * Button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
+     * Flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
      */
     public static native boolean invisibleButton(String strId, float width, float height); /*
         return ImGui::InvisibleButton(strId, ImVec2(width, height));
     */
 
+    /**
+     * Flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
+     */
+    public static native boolean invisibleButton(String strId, float width, float height, int imGuiButtonFlags); /*
+        return ImGui::InvisibleButton(strId, ImVec2(width, height), imGuiButtonFlags);
+    */
+
     /**
      * Square button with an arrow shape
      */
@@ -1675,7 +1682,7 @@ public final class ImGui {
     */
 
     /**
-     * Draw a small circle and keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
+     * Draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
      */
     public static native void bullet(); /*
         ImGui::Bullet();
@@ -1733,14 +1740,18 @@ public final class ImGui {
         return ImGui::Combo(label, &currentItem[0], itemsSeparatedByZeros, popupMaxHeightInItems);
     */
 
-    // Widgets: Drags
+    // Widgets: Drag Sliders
     // - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped and can go off-bounds.
     // - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
     // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
+    // - Format string may also be set to NULL or use the default format ("%f" or "%d").
     // - Speed are per-pixel of mouse movement (vSpeed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(vSpeed, minimum_step_at_given_precision).
     // - Use vMin < vMax to clamp edits to given limits. Note that CTRL+Click manual input can override those limits.
     // - Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.
     // - Use vMin > vMax to lock edits.
+    // - We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
+    // - Legacy: Pre-1.78 there are DragXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
+    //   If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
 
     public static native boolean dragFloat(String label, float[] v); /*
         return ImGui::DragFloat(label, &v[0]);
@@ -1767,8 +1778,8 @@ public final class ImGui {
     /**
      * If {@code vMin >= vMax} we have no bound
      */
-    public static native boolean dragFloat(String label, float[] v, float vSpeed, float vMin, float vMax, String format, float power); /*
+    public static native boolean dragFloat(String label, float[] v, float vSpeed, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragFloat(label, &v[0], vSpeed, vMin, vMax, format, power);
+        return ImGui::DragFloat(label, &v[0], vSpeed, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean dragFloat2(String label, float[] v); /*
@@ -1791,8 +1802,8 @@ public final class ImGui {
         return ImGui::DragFloat2(label, v, vSpeed, vMin, vMax, format);
     */
 
-    public static native boolean dragFloat2(String label, float[] v, float vSpeed, float vMin, float vMax, String format, float power); /*
+    public static native boolean dragFloat2(String label, float[] v, float vSpeed, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragFloat2(label, v, vSpeed, vMin, vMax, format, power);
+        return ImGui::DragFloat2(label, v, vSpeed, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean dragFloat3(String label, float[] v); /*
@@ -1815,8 +1826,8 @@ public final class ImGui {
         return ImGui::DragFloat3(label, v, vSpeed, vMin, vMax, format);
     */
 
-    public static native boolean dragFloat3(String label, float[] v, float vSpeed, float vMin, float vMax, String format, float power); /*
+    public static native boolean dragFloat3(String label, float[] v, float vSpeed, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragFloat3(label, v, vSpeed, vMin, vMax, format, power);
+        return ImGui::DragFloat3(label, v, vSpeed, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean dragFloat4(String label, float[] v); /*
@@ -1839,8 +1850,8 @@ public final class ImGui {
         return ImGui::DragFloat4(label, v, vSpeed, vMin, vMax, format);
     */
 
-    public static native boolean dragFloat4(String label, float[] v, float vSpeed, float vMin, float vMax, String format, float power); /*
+    public static native boolean dragFloat4(String label, float[] v, float vSpeed, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragFloat4(label, v, vSpeed, vMin, vMax, format, power);
+        return ImGui::DragFloat4(label, v, vSpeed, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean dragFloatRange2(String label, float[] vCurrentMin, float[] vCurrentMax); /*
@@ -1867,8 +1878,8 @@ public final class ImGui {
         return ImGui::DragFloatRange2(label, &vCurrentMin[0], &vCurrentMax[0], vSpeed, vMin, vMax, format, formatMax);
     */
 
-    public static native boolean dragFloatRange2(String label, float[] vCurrentMin, float[] vCurrentMax, float vSpeed, float vMin, float vMax, String format, String formatMax, float power); /*
+    public static native boolean dragFloatRange2(String label, float[] vCurrentMin, float[] vCurrentMax, float vSpeed, float vMin, float vMax, String format, String formatMax, int imGuiSliderFlags); /*
-        return ImGui::DragFloatRange2(label, &vCurrentMin[0], &vCurrentMax[0], vSpeed, vMin, vMax, format, formatMax, power);
+        return ImGui::DragFloatRange2(label, &vCurrentMin[0], &vCurrentMax[0], vSpeed, vMin, vMax, format, formatMax, imGuiSliderFlags);
     */
 
     public static native boolean dragInt(String label, int[] v); /*
@@ -2006,15 +2017,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalar(String label, int dataType, ImInt pData, float vSpeed, int pMin, int pMax, String format) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalar(String label, int dataType, ImInt pData, float vSpeed, int pMin, int pMax, String format, float power) {
+    public static boolean dragScalar(String label, int dataType, ImInt pData, float vSpeed, int pMin, int pMax, String format, int imGuiSliderFlags) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, power);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalar(String label, int dataType, int[] pData, float vSpeed, int pMin, int pMax, String format, float power); /*
+    private static native boolean nDragScalar(String label, int dataType, int[] pData, float vSpeed, int pMin, int pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalar(String label, int dataType, ImFloat pData, float vSpeed) {
@@ -2042,15 +2053,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalar(String label, int dataType, ImFloat pData, float vSpeed, float pMin, float pMax, String format) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalar(String label, int dataType, ImFloat pData, float vSpeed, float pMin, float pMax, String format, float power) {
+    public static boolean dragScalar(String label, int dataType, ImFloat pData, float vSpeed, float pMin, float pMax, String format, int imGuiSliderFlags) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, power);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalar(String label, int dataType, float[] pData, float vSpeed, float pMin, float pMax, String format, float power); /*
+    private static native boolean nDragScalar(String label, int dataType, float[] pData, float vSpeed, float pMin, float pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalar(String label, int dataType, ImDouble pData, float vSpeed) {
@@ -2078,15 +2089,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalar(String label, int dataType, ImDouble pData, float vSpeed, double pMin, double pMax, String format) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalar(String label, int dataType, ImDouble pData, float vSpeed, double pMin, double pMax, String format, float power) {
+    public static boolean dragScalar(String label, int dataType, ImDouble pData, float vSpeed, double pMin, double pMax, String format, int imGuiSliderFlags) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, power);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalar(String label, int dataType, double[] pData, float vSpeed, double pMin, double pMax, String format, float power); /*
+    private static native boolean nDragScalar(String label, int dataType, double[] pData, float vSpeed, double pMin, double pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalar(String label, int dataType, ImLong pData, float vSpeed) {
@@ -2114,15 +2125,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalar(String label, int dataType, ImLong pData, float vSpeed, long pMin, long pMax, String format) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalar(String label, int dataType, ImLong pData, float vSpeed, long pMin, long pMax, String format, float power) {
+    public static boolean dragScalar(String label, int dataType, ImLong pData, float vSpeed, long pMin, long pMax, String format, int imGuiSliderFlags) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, power);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalar(String label, int dataType, long[] pData, float vSpeed, long pMin, long pMax, String format, float power); /*
+    private static native boolean nDragScalar(String label, int dataType, long[] pData, float vSpeed, long pMin, long pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalar(String label, int dataType, ImShort pData, float vSpeed) {
@@ -2150,15 +2161,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalar(String label, int dataType, ImShort pData, float vSpeed, short pMin, short pMax, String format) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalar(String label, int dataType, ImShort pData, float vSpeed, short pMin, short pMax, String format, float power) {
+    public static boolean dragScalar(String label, int dataType, ImShort pData, float vSpeed, short pMin, short pMax, String format, int imGuiSliderFlags) {
-        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, power);
+        return nDragScalar(label, dataType, pData.getData(), vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalar(String label, int dataType, short[] pData, float vSpeed, short pMin, short pMax, String format, float power); /*
+    private static native boolean nDragScalar(String label, int dataType, short[] pData, float vSpeed, short pMin, short pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalar(label, dataType, &pData[0], vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalarN(String label, int dataType, ImInt pData, int components, float vSpeed) {
@@ -2186,15 +2197,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalarN(String label, int dataType, ImInt pData, int components, float vSpeed, int pMin, int pMax, String format) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalarN(String label, int dataType, ImInt pData, int components, float vSpeed, int pMin, int pMax, String format, float power) {
+    public static boolean dragScalarN(String label, int dataType, ImInt pData, int components, float vSpeed, int pMin, int pMax, String format, int imGuiSliderFlags) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, power);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalarN(String label, int dataType, int[] pData, int components, float vSpeed, int pMin, int pMax, String format, float power); /*
+    private static native boolean nDragScalarN(String label, int dataType, int[] pData, int components, float vSpeed, int pMin, int pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalarN(String label, int dataType, ImFloat pData, int components, float vSpeed) {
@@ -2222,15 +2233,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalarN(String label, int dataType, ImFloat pData, int components, float vSpeed, float pMin, float pMax, String format) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalarN(String label, int dataType, ImFloat pData, int components, float vSpeed, float pMin, float pMax, String format, float power) {
+    public static boolean dragScalarN(String label, int dataType, ImFloat pData, int components, float vSpeed, float pMin, float pMax, String format, int imGuiSliderFlags) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, power);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalarN(String label, int dataType, float[] pData, int components, float vSpeed, float pMin, float pMax, String format, float power); /*
+    private static native boolean nDragScalarN(String label, int dataType, float[] pData, int components, float vSpeed, float pMin, float pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalarN(String label, int dataType, ImDouble pData, int components, float vSpeed) {
@@ -2258,15 +2269,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalarN(String label, int dataType, ImDouble pData, int components, float vSpeed, double pMin, double pMax, String format) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalarN(String label, int dataType, ImDouble pData, int components, float vSpeed, double pMin, double pMax, String format, float power) {
+    public static boolean dragScalarN(String label, int dataType, ImDouble pData, int components, float vSpeed, double pMin, double pMax, String format, int imGuiSliderFlags) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, power);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalarN(String label, int dataType, double[] pData, int components, float vSpeed, double pMin, double pMax, String format, float power); /*
+    private static native boolean nDragScalarN(String label, int dataType, double[] pData, int components, float vSpeed, double pMin, double pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalarN(String label, int dataType, ImLong pData, int components, float vSpeed) {
@@ -2294,15 +2305,15 @@ public final class ImGui {
     */
 
     public static boolean dragScalarN(String label, int dataType, ImLong pData, int components, float vSpeed, long pMin, long pMax, String format) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalarN(String label, int dataType, ImLong pData, int components, float vSpeed, long pMin, long pMax, String format, float power) {
+    public static boolean dragScalarN(String label, int dataType, ImLong pData, int components, float vSpeed, long pMin, long pMax, String format, int imGuiSliderFlags) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, power);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalarN(String label, int dataType, long[] pData, int components, float vSpeed, long pMin, long pMax, String format, float power); /*
+    private static native boolean nDragScalarN(String label, int dataType, long[] pData, int components, float vSpeed, long pMin, long pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
     public static boolean dragScalarN(String label, int dataType, ImShort pData, int components, float vSpeed) {
@@ -2330,23 +2341,26 @@ public final class ImGui {
     */
 
     public static boolean dragScalarN(String label, int dataType, ImShort pData, int components, float vSpeed, short pMin, short pMax, String format) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 1.0f);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, 0);
     }
 
-    public static boolean dragScalarN(String label, int dataType, ImShort pData, int components, float vSpeed, short pMin, short pMax, String format, float power) {
+    public static boolean dragScalarN(String label, int dataType, ImShort pData, int components, float vSpeed, short pMin, short pMax, String format, int imGuiSliderFlags) {
-        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, power);
+        return nDragScalarN(label, dataType, pData.getData(), components, vSpeed, pMin, pMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nDragScalarN(String label, int dataType, short[] pData, int components, float vSpeed, short pMin, short pMax, String format, float power); /*
+    private static native boolean nDragScalarN(String label, int dataType, short[] pData, int components, float vSpeed, short pMin, short pMax, String format, int imGuiSliderFlags); /*
-        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, power);
+        return ImGui::DragScalarN(label, dataType, &pData[0], components, vSpeed, &pMin, &pMax, format, imGuiSliderFlags);
     */
 
-    // Widgets: Sliders
+    // Widgets: Regular Sliders
     // - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped and can go off-bounds.
     // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
+    // - Format string may also be set to NULL or use the default format ("%f" or "%d").
+    // - Legacy: Pre-1.78 there are SliderXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
+    //   If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
 
     /**
-     * Adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display. Use power!=1.0 for power curve sliders
+     * Adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display.
      */
     public static native boolean sliderFloat(String label, float[] v, float vMin, float vMax); /*
         return ImGui::SliderFloat(label, &v[0],vMin, vMax);
@@ -2356,8 +2370,8 @@ public final class ImGui {
         return ImGui::SliderFloat(label, &v[0], vMin, vMax, format);
     */
 
-    public static native boolean sliderFloat(String label, float[] v, float vMin, float vMax, String format, float power); /*
+    public static native boolean sliderFloat(String label, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderFloat(label, &v[0], vMin, vMax, format, power);
+        return ImGui::SliderFloat(label, &v[0], vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean sliderFloat2(String label, float[] v, float vMin, float vMax); /*
@@ -2368,8 +2382,8 @@ public final class ImGui {
         return ImGui::SliderFloat2(label, v, vMin, vMax, format);
     */
 
-    public static native boolean sliderFloat2(String label, float[] v, float vMin, float vMax, String format, float power); /*
+    public static native boolean sliderFloat2(String label, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderFloat2(label, v, vMin, vMax, format, power);
+        return ImGui::SliderFloat2(label, v, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean sliderFloat3(String label, float[] v, float vMin, float vMax); /*
@@ -2380,8 +2394,8 @@ public final class ImGui {
         return ImGui::SliderFloat3(label, v, vMin, vMax, format);
     */
 
-    public static native boolean sliderFloat3(String label, float[] v, float vMin, float vMax, String format, float power); /*
+    public static native boolean sliderFloat3(String label, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderFloat3(label, v, vMin, vMax, format, power);
+        return ImGui::SliderFloat3(label, v, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean sliderFloat4(String label, float[] v, float vMin, float vMax); /*
@@ -2392,8 +2406,8 @@ public final class ImGui {
         return ImGui::SliderFloat4(label, v, vMin, vMax, format);
     */
 
-    public static native boolean sliderFloat4(String label, float[] v, float vMin, float vMax, String format, float power); /*
+    public static native boolean sliderFloat4(String label, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderFloat4(label, v, vMin, vMax, format, power);
+        return ImGui::SliderFloat4(label, v, vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean sliderAngle(String label, float[] vRad); /*
@@ -2453,15 +2467,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalar(String label, int dataType, ImInt v, int vMin, int vMax, String format) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalar(String label, int dataType, ImInt v, int vMin, int vMax, String format, float power) {
+    public static boolean sliderScalar(String label, int dataType, ImInt v, int vMin, int vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, power);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalar(String label, int dataType, int[] v, int vMin, int vMax, String format, float power); /*
+    private static native boolean nSliderScalar(String label, int dataType, int[] v, int vMin, int vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalar(String label, int dataType, ImFloat v, float vMin, float vMax) {
@@ -2473,15 +2487,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalar(String label, int dataType, ImFloat v, float vMin, float vMax, String format) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalar(String label, int dataType, ImFloat v, float vMin, float vMax, String format, float power) {
+    public static boolean sliderScalar(String label, int dataType, ImFloat v, float vMin, float vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, power);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalar(String label, int dataType, float[] v, float vMin, float vMax, String format, float power); /*
+    private static native boolean nSliderScalar(String label, int dataType, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalar(String label, int dataType, ImLong v, long vMin, long vMax) {
@@ -2493,15 +2507,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalar(String label, int dataType, ImLong v, long vMin, long vMax, String format) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalar(String label, int dataType, ImLong v, long vMin, long vMax, String format, float power) {
+    public static boolean sliderScalar(String label, int dataType, ImLong v, long vMin, long vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, power);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalar(String label, int dataType, long[] v, long vMin, long vMax, String format, float power); /*
+    private static native boolean nSliderScalar(String label, int dataType, long[] v, long vMin, long vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalar(String label, int dataType, ImDouble v, double vMin, double vMax) {
@@ -2513,15 +2527,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalar(String label, int dataType, ImDouble v, double vMin, double vMax, String format) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalar(String label, int dataType, ImDouble v, double vMin, double vMax, String format, float power) {
+    public static boolean sliderScalar(String label, int dataType, ImDouble v, double vMin, double vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, power);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalar(String label, int dataType, double[] v, double vMin, double vMax, String format, float power); /*
+    private static native boolean nSliderScalar(String label, int dataType, double[] v, double vMin, double vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalar(String label, int dataType, ImShort v, short vMin, short vMax) {
@@ -2533,15 +2547,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalar(String label, int dataType, ImShort v, short vMin, short vMax, String format) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalar(String label, int dataType, ImShort v, short vMin, short vMax, String format, float power) {
+    public static boolean sliderScalar(String label, int dataType, ImShort v, short vMin, short vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, power);
+        return nSliderScalar(label, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalar(String label, int dataType, short[] v, short vMin, short vMax, String format, float power); /*
+    private static native boolean nSliderScalar(String label, int dataType, short[] v, short vMin, short vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::SliderScalar(label, dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImInt v, int vMin, int vMax) {
@@ -2553,15 +2567,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImInt v, int vMin, int vMax, String format) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalarN(String label, int dataType, int components, ImInt v, int vMin, int vMax, String format, float power) {
+    public static boolean sliderScalarN(String label, int dataType, int components, ImInt v, int vMin, int vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, power);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalarN(String label, int dataType, int components, int[] v, int vMin, int vMax, String format, float power); /*
+    private static native boolean nSliderScalarN(String label, int dataType, int components, int[] v, int vMin, int vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, power);
+        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImFloat v, float vMin, float vMax) {
@@ -2573,15 +2587,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImFloat v, float vMin, float vMax, String format) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalarN(String label, int dataType, int components, ImFloat v, float vMin, float vMax, String format, float power) {
+    public static boolean sliderScalarN(String label, int dataType, int components, ImFloat v, float vMin, float vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, power);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalarN(String label, int dataType, int components, float[] v, float vMin, float vMax, String format, float power); /*
+    private static native boolean nSliderScalarN(String label, int dataType, int components, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, power);
+        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImLong v, long vMin, long vMax) {
@@ -2593,15 +2607,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImLong v, long vMin, long vMax, String format) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalarN(String label, int dataType, int components, ImLong v, long vMin, long vMax, String format, float power) {
+    public static boolean sliderScalarN(String label, int dataType, int components, ImLong v, long vMin, long vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, power);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalarN(String label, int dataType, int components, long[] v, long vMin, long vMax, String format, float power); /*
+    private static native boolean nSliderScalarN(String label, int dataType, int components, long[] v, long vMin, long vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, power);
+        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImDouble v, double vMin, double vMax) {
@@ -2613,15 +2627,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImDouble v, double vMin, double vMax, String format) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalarN(String label, int dataType, int components, ImDouble v, double vMin, double vMax, String format, float power) {
+    public static boolean sliderScalarN(String label, int dataType, int components, ImDouble v, double vMin, double vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, power);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalarN(String label, int dataType, int components, double[] v, double vMin, double vMax, String format, float power); /*
+    private static native boolean nSliderScalarN(String label, int dataType, int components, double[] v, double vMin, double vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, power);
+        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImShort v, short vMin, short vMax) {
@@ -2633,15 +2647,15 @@ public final class ImGui {
     */
 
     public static boolean sliderScalarN(String label, int dataType, int components, ImShort v, short vMin, short vMax, String format) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 1.0f);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean sliderScalarN(String label, int dataType, int components, ImShort v, short vMin, short vMax, String format, float power) {
+    public static boolean sliderScalarN(String label, int dataType, int components, ImShort v, short vMin, short vMax, String format, int imGuiSliderFlags) {
-        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, power);
+        return nSliderScalarN(label, dataType, components, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nSliderScalarN(String label, int dataType, int components, short[] v, short vMin, short vMax, String format, float power); /*
+    private static native boolean nSliderScalarN(String label, int dataType, int components, short[] v, short vMin, short vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, power);
+        return ImGui::SliderScalarN(label, dataType, &v[0], components, &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean vSliderFloat(String label, float sizeX, float sizeY, float[] v, float vMin, float vMax); /*
@@ -2652,8 +2666,8 @@ public final class ImGui {
         return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], vMin, vMax);
     */
 
-    public static native boolean vSliderFloat(String label, float sizeX, float sizeY, float[] v, float vMin, float vMax, String format, float power); /*
+    public static native boolean vSliderFloat(String label, float sizeX, float sizeY, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], vMin, vMax, format, power);
+        return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], vMin, vMax, format, imGuiSliderFlags);
     */
 
     public static native boolean vSliderInt(String label, float sizeX, float sizeY, int[] v, int vMin, int vMax); /*
@@ -2673,15 +2687,15 @@ public final class ImGui {
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImInt v, int vMin, int vMax, String format) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImInt v, int vMin, int vMax, String format, float power) {
+    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImInt v, int vMin, int vMax, String format, int imGuiSliderFlags) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, power);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, int[] v, int vMin, int vMax, String format, float power); /*
+    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, int[] v, int vMin, int vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImFloat v, float vMin, float vMax) {
@@ -2693,15 +2707,15 @@ public final class ImGui {
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImFloat v, float vMin, float vMax, String format) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImFloat v, float vMin, float vMax, String format, float power) {
+    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImFloat v, float vMin, float vMax, String format, int imGuiSliderFlags) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, power);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, float[] v, float vMin, float vMax, String format, float power); /*
+    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, float[] v, float vMin, float vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImLong v, long vMin, long vMax) {
@@ -2713,15 +2727,15 @@ public final class ImGui {
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImLong v, long vMin, long vMax, String format) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImLong v, long vMin, long vMax, String format, float power) {
+    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImLong v, long vMin, long vMax, String format, int imGuiSliderFlags) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, power);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, long[] v, long vMin, long vMax, String format, float power); /*
+    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, long[] v, long vMin, long vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImDouble v, double vMin, double vMax) {
@@ -2733,15 +2747,15 @@ public final class ImGui {
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImDouble v, double vMin, double vMax, String format) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImDouble v, double vMin, double vMax, String format, float power) {
+    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImDouble v, double vMin, double vMax, String format, int imGuiSliderFlags) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, power);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, double[] v, double vMin, double vMax, String format, float power); /*
+    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, double[] v, double vMin, double vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImShort v, short vMin, short vMax) {
@@ -2753,15 +2767,15 @@ public final class ImGui {
     */
 
     public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImShort v, short vMin, short vMax, String format) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 1.0f);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, 0);
     }
 
-    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImShort v, short vMin, short vMax, String format, float power) {
+    public static boolean vSliderScalar(String label, float sizeX, float sizeY, int dataType, ImShort v, short vMin, short vMax, String format, int imGuiSliderFlags) {
-        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, power);
+        return nVSliderScalar(label, sizeX, sizeY, dataType, v.getData(), vMin, vMax, format, imGuiSliderFlags);
     }
 
-    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, short[] v, short vMin, short vMax, String format, float power); /*
+    private static native boolean nVSliderScalar(String label, float sizeX, float sizeY, int dataType, short[] v, short vMin, short vMax, String format, int imGuiSliderFlags); /*
-        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, power);
+        return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), dataType, &v[0], &vMin, &vMax, format, imGuiSliderFlags);
     */
 
     // Widgets: Input with Keyboard
@@ -5156,7 +5170,7 @@ public final class ImGui {
     */
 
     /**
-     * Did mouse button double-clicked. a double-click returns false in IsMouseClicked(). uses io.MouseDoubleClickTime.
+     * did mouse button double-clicked? (note that a double-click will also report IsMouseClicked() == true).
      */
     public static native boolean isMouseDoubleClicked(int button); /*
         return ImGui::IsMouseDoubleClicked(button);

imgui-binding/src/main/java/imgui/ImGuiListClipper.java

@@ -16,7 +16,7 @@ import imgui.callback.ImListClipperCallback;
  * </pre>
  * - Step 0: the clipper let you process the first element, regardless of it being visible or not, so we can measure the element height (step skipped if we passed a known height as second arg to constructor).
  * - Step 1: the clipper infer height from first element, calculate the actual range of elements to display, and position the cursor before the first element.
- * - (Step 2: dummy step only required if an explicit items_height was passed to constructor or Begin() and user call Step(). Does nothing and switch to Step 3.)
+ * - (Step 2: empty step only required if an explicit items_height was passed to constructor or Begin() and user call Step(). Does nothing and switch to Step 3.)
  * - Step 3: the clipper validate that we have reached the expected Y position (corresponding to element DisplayEnd), advance the cursor to the end of the list and then returns 'false' to end the loop.
  * <p>
  * BINDING NOTICE:

imgui-binding/src/main/java/imgui/ImGuiStyle.java

@@ -466,6 +466,20 @@ public final class ImGuiStyle extends ImGuiStructDestroyable {
         IMGUI_STYLE->GrabRounding = grabRounding;
     */
 
+    /**
+     * The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
+     */
+    public native float getLogSliderDeadzone(); /*
+        return IMGUI_STYLE->LogSliderDeadzone;
+    */
+
+    /**
+     * The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
+     */
+    public native void setLogSliderDeadzone(float logSliderDeadzone); /*
+        IMGUI_STYLE->LogSliderDeadzone = logSliderDeadzone;
+    */
+
     /**
      * Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs.
      */
@@ -663,28 +677,48 @@ public final class ImGuiStyle extends ImGuiStructDestroyable {
     */
 
     /**
-     * Enable anti-aliasing on lines/borders. Disable if you are really tight on CPU/GPU.
+     * Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
      */
     public native boolean getAntiAliasedLines(); /*
         return IMGUI_STYLE->AntiAliasedLines;
     */
 
     /**
-     * Enable anti-aliasing on lines/borders. Disable if you are really tight on CPU/GPU.
+     * Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
      */
     public native void setAntiAliasedLines(boolean antiAliasedLines); /*
         IMGUI_STYLE->AntiAliasedLines = antiAliasedLines;
     */
 
     /**
-     * Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
+     * Enable anti-aliased lines/borders using textures where possible.
+     * Require back-end to render with bilinear filtering.
+     * Latched at the beginning of the frame (copied to ImDrawList).
+     */
+    public native boolean getAntiAliasedLinesUseTex(); /*
+        return IMGUI_STYLE->AntiAliasedLinesUseTex;
+    */
+
+    /**
+     * Enable anti-aliased lines/borders using textures where possible.
+     * Require back-end to render with bilinear filtering.
+     * Latched at the beginning of the frame (copied to ImDrawList).
+     */
+    public native void setAntiAliasedLinesUseTex(boolean antiAliasedLinesUseTex); /*
+        IMGUI_STYLE->AntiAliasedLinesUseTex = antiAliasedLinesUseTex;
+    */
+
+    /**
+     * Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.).
+     * Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
      */
     public native boolean getAntiAliasedFill(); /*
         return IMGUI_STYLE->AntiAliasedFill;
     */
 
     /**
-     * Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
+     * Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.).
+     * Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
      */
     public native void setAntiAliasedFill(boolean antiAliasedFill); /*
         IMGUI_STYLE->AntiAliasedFill = antiAliasedFill;

imgui-binding/src/main/java/imgui/flag/ImDrawListFlags.java

@@ -1,21 +1,28 @@
 package imgui.flag;
 
+/**
+ * Flags for ImDrawList. Those are set automatically by ImGui:: functions from ImGuiIO settings, and generally not manipulated directly.
+ * It is however possible to temporarily alter flags between calls to ImDrawList:: functions.
+ */
 public final class ImDrawListFlags {
     private ImDrawListFlags() {
     }
 
     public static final int None = 0;
-
     /**
-     * Lines are anti-aliased (*2 the number of triangles for 1.0f wide line, otherwise *3 the number of triangles)
+     * Enable anti-aliased lines/borders (*2 the number of triangles for 1.0f wide line or lines thin enough to be drawn using textures, otherwise *3 the number of triangles)
      */
     public static final int AntiAliasedLines = 1;
     /**
-     * Filled shapes have anti-aliased edges (*2 the number of vertices)
+     * Enable anti-aliased lines/borders using textures when possible. Require back-end to render with bilinear filtering.
      */
-    public static final int AntiAliasedFill = 1 << 1;
+    public static final int AntiAliasedLinesUseTex = 1 << 1;
     /**
-     * Can emit 'VtxOffset {@code >} 0' to allow large meshes. Set when 'ImGuiBackendFlags_RendererHasVtxOffset' is enabled.
+     * Enable anti-aliased edge around filled shapes (rounded rectangles, circles).
      */
-    public static final int AllowVtxOffset = 1 << 2;
+    public static final int AntiAliasedFill = 1 << 2;
+    /**
+     * Can emit 'VtxOffset > 0' to allow large meshes. Set when 'ImGuiBackendFlags_RendererHasVtxOffset' is enabled.
+     */
+    public static final int AllowVtxOffset = 1 << 3;
 }

imgui-binding/src/main/java/imgui/flag/ImFontAtlasFlags.java

@@ -1,5 +1,8 @@
 package imgui.flag;
 
+/**
+ * Flags for ImFontAtlas build
+ */
 public final class ImFontAtlasFlags {
     private ImFontAtlasFlags() {
     }
@@ -13,4 +16,9 @@ public final class ImFontAtlasFlags {
      * Don't build software mouse cursors into the atlas
      */
     public static final int NoMouseCursors = 1 << 1;
+    /**
+     * Don't build thick line textures into the atlas (save a little texture memory).
+     * The AntiAliasedLinesUseTex features uses them, otherwise they will be rendered using polygons (more expensive for CPU/GPU).
+     */
+    public static final int NoBakedLines = 1 << 2;
 }

imgui-binding/src/main/java/imgui/flag/ImGuiButtonFlags.java

@@ -0,0 +1,20 @@
+package imgui.flag;
+
+public final class ImGuiButtonFlags {
+    private ImGuiButtonFlags() {
+    }
+
+    public static final int None = 0;
+    /**
+     * React on left mouse button (default).
+     */
+    public static final int MouseButtonLeft = 0;
+    /**
+     *  React on right mouse button.
+     */
+    public static final int MouseButtonRight = 1 << 1;
+    /**
+     * React on center mouse button.
+     */
+    public static final int MouseButtonMiddle = 1 << 2;
+}

imgui-binding/src/main/java/imgui/flag/ImGuiPopupFlags.java

@@ -6,6 +6,7 @@ package imgui.flag;
  *   small flags values as a mouse button index, so we encode the mouse button in the first few bits of the flags.
  *   It is therefore guaranteed to be legal to pass a mouse button index in ImGuiPopupFlags.
  * - For the same reason, we exceptionally default the ImGuiPopupFlags argument of BeginPopupContextXXX functions to 1 instead of 0.
+ * - Multiple buttons currently cannot be combined/or-ed in those functions (we could allow it later).
  */
 public final class ImGuiPopupFlags {
     private ImGuiPopupFlags() {

imgui-binding/src/main/java/imgui/flag/ImGuiSliderFlags.java

@@ -0,0 +1,25 @@
+package imgui.flag;
+
+public final class ImGuiSliderFlags {
+    private ImGuiSliderFlags() {
+    }
+
+    public static final int None = 0;
+    /**
+     * Clamp value to min/max bounds when input manually with CTRL+Click. By default CTRL+Click allows going out of bounds.
+     */
+    public static final int ClampOnInput = 1 << 4;
+    /**
+     * Make the widget logarithmic (linear otherwise).
+     * Consider using ImGuiSliderFlags_NoRoundToFormat with this if using a format-string with small amount of digits.
+     */
+    public static final int Logarithmic = 1 << 5;
+    /**
+     * Disable rounding underlying value to match precision of the display format string (e.g. %.3f values are rounded to those 3 digits).
+     */
+    public static final int NoRoundToFormat = 1 << 6;
+    /**
+     * Disable CTRL+Click or Enter key allowing to input text directly into the widget
+     */
+    public static final int NoInput = 1 << 7;
+}

imgui-lwjgl3/src/main/java/imgui/gl3/ImGuiImplGl3.java

@@ -21,7 +21,7 @@ import static org.lwjgl.opengl.GL32.*;
 
 /**
  * This class is a straightforward port of the
- * <a href="https://raw.githubusercontent.com/ocornut/imgui/v1.76/examples/imgui_impl_opengl3.cpp">imgui_impl_opengl3.cpp</a>.
+ * <a href="https://raw.githubusercontent.com/ocornut/imgui/05bc204dbd80dfebb3dab1511caf1cb980620c76/examples/imgui_impl_opengl3.cpp">imgui_impl_opengl3.cpp</a>.
  * <p>
  * It do support a backup and restoring of the GL state in the same way the original Dear ImGui code does.
  * Some of the very specific OpenGL variables may be ignored here,

imgui-lwjgl3/src/main/java/imgui/glfw/ImGuiImplGlfw.java

@@ -38,7 +38,7 @@ import static org.lwjgl.system.MemoryUtil.NULL;
 
 /**
  * This class is a straightforward port of the
- * <a href="https://raw.githubusercontent.com/ocornut/imgui/v1.77/examples/imgui_impl_glfw.cpp">imgui_impl_glfw.cpp</a>.
+ * <a href="https://raw.githubusercontent.com/ocornut/imgui/05bc204dbd80dfebb3dab1511caf1cb980620c76/examples/imgui_impl_glfw.cpp">imgui_impl_glfw.cpp</a>.
  * <p>
  * It supports clipboard, gamepad, mouse and keyboard in the same way the original Dear ImGui code does. You can copy-paste this class in your codebase and
  * modify the rendering routine in the way you'd like.

imgui-lwjgl3/src/test/java/ExampleUi.java

@@ -17,7 +17,7 @@ import static org.lwjgl.opengl.GL32.*;
 
 @SuppressWarnings({"MagicNumber", "VisibilityModifier"})
 final class ExampleUi {
-    private static final String IMGUI_DEMO_LINK = "https://raw.githubusercontent.com/ocornut/imgui/v1.77/imgui_demo.cpp";
+    private static final String IMGUI_DEMO_LINK = "https://raw.githubusercontent.com/ocornut/imgui/05bc204/imgui_demo.cpp";
 
     private static final int COLOR_DODGERBLUE = ImColor.rgbToColor("#1E90FF");
     private static final int COLOR_CORAL = ImColor.rgbToColor("#FF7F50");