Order Functions alphabetically by name

* This helps with consistency between versions, since the json file does not always preserve order.

src/CodeGenerator/Program.cs

@@ -218,7 +218,7 @@ namespace CodeGenerator
                 }).Where(od => od != null).ToArray();
 
                 return new FunctionDefinition(name, overloads);
-            }).ToArray();
+            }).OrderBy(fd => fd.Name).ToArray();
 
             foreach (EnumDefinition ed in enums)
             {

src/ImGui.NET/Generated/GlyphRangesBuilder.gen.cs

@@ -18,9 +18,14 @@ namespace ImGuiNET
         public static implicit operator GlyphRangesBuilder* (GlyphRangesBuilderPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator GlyphRangesBuilderPtr(IntPtr nativePtr) => new GlyphRangesBuilderPtr(nativePtr);
         public ImVector<byte> UsedChars => new ImVector<byte>(NativePtr->UsedChars);
-        public void SetBit(int n)
+        public void AddChar(ushort c)
         {
-            ImGuiNative.GlyphRangesBuilder_SetBit(NativePtr, n);
+            ImGuiNative.GlyphRangesBuilder_AddChar(NativePtr, c);
+        }
+        public void AddRanges(IntPtr ranges)
+        {
+            ushort* native_ranges = (ushort*)ranges.ToPointer();
+            ImGuiNative.GlyphRangesBuilder_AddRanges(NativePtr, native_ranges);
         }
         public void AddText(string text)
         {
@@ -40,11 +45,6 @@ namespace ImGuiNET
             byte* native_text_end = null;
             ImGuiNative.GlyphRangesBuilder_AddText(NativePtr, native_text, native_text_end);
         }
-        public void AddRanges(IntPtr ranges)
-        {
-            ushort* native_ranges = (ushort*)ranges.ToPointer();
-            ImGuiNative.GlyphRangesBuilder_AddRanges(NativePtr, native_ranges);
-        }
         public void BuildRanges(out ImVector out_ranges)
         {
             fixed (ImVector* native_out_ranges = &out_ranges)
@@ -57,9 +57,9 @@ namespace ImGuiNET
             byte ret = ImGuiNative.GlyphRangesBuilder_GetBit(NativePtr, n);
             return ret != 0;
         }
-        public void AddChar(ushort c)
+        public void SetBit(int n)
         {
-            ImGuiNative.GlyphRangesBuilder_AddChar(NativePtr, c);
+            ImGuiNative.GlyphRangesBuilder_SetBit(NativePtr, n);
         }
     }
 }

src/ImGui.NET/Generated/ImColor.gen.cs

@@ -18,15 +18,6 @@ namespace ImGuiNET
         public static implicit operator ImColor* (ImColorPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImColorPtr(IntPtr nativePtr) => new ImColorPtr(nativePtr);
         public ref Vector4 Value => ref Unsafe.AsRef<Vector4>(&NativePtr->Value);
-        public void SetHSV(float h, float s, float v)
-        {
-            float a = 1.0f;
-            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
-        }
-        public void SetHSV(float h, float s, float v, float a)
-        {
-            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
-        }
         public ImColor HSV(float h, float s, float v)
         {
             float a = 1.0f;
@@ -38,5 +29,14 @@ namespace ImGuiNET
             ImColor ret = ImGuiNative.ImColor_HSV(NativePtr, h, s, v, a);
             return ret;
         }
+        public void SetHSV(float h, float s, float v)
+        {
+            float a = 1.0f;
+            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
+        }
+        public void SetHSV(float h, float s, float v, float a)
+        {
+            ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
+        }
     }
 }

src/ImGui.NET/Generated/ImDrawData.gen.cs

@@ -30,17 +30,17 @@ namespace ImGuiNET
         public ref int TotalVtxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalVtxCount);
         public ref Vector2 DisplayPos => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayPos);
         public ref Vector2 DisplaySize => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySize);
-        public void ScaleClipRects(Vector2 sc)
+        public void Clear()
         {
-            ImGuiNative.ImDrawData_ScaleClipRects(NativePtr, sc);
+            ImGuiNative.ImDrawData_Clear(NativePtr);
         }
         public void DeIndexAllBuffers()
         {
             ImGuiNative.ImDrawData_DeIndexAllBuffers(NativePtr);
         }
-        public void Clear()
+        public void ScaleClipRects(Vector2 sc)
         {
-            ImGuiNative.ImDrawData_Clear(NativePtr);
+            ImGuiNative.ImDrawData_ScaleClipRects(NativePtr, sc);
         }
     }
 }

src/ImGui.NET/Generated/ImDrawList.gen.cs

@@ -46,114 +46,154 @@ namespace ImGuiNET
         public ref int _ChannelsCurrent => ref Unsafe.AsRef<int>(&NativePtr->_ChannelsCurrent);
         public ref int _ChannelsCount => ref Unsafe.AsRef<int>(&NativePtr->_ChannelsCount);
         public ImPtrVector<ImDrawChannelPtr> _Channels => new ImPtrVector<ImDrawChannelPtr>(NativePtr->_Channels, Unsafe.SizeOf<ImDrawChannel>());
-        public void ChannelsSetCurrent(int channel_index)
+        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_ChannelsSetCurrent(NativePtr, channel_index);
+            int num_segments = 0;
+            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
         }
-        public void ChannelsSplit(int channels_count)
+        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness, int num_segments)
         {
-            ImGuiNative.ImDrawList_ChannelsSplit(NativePtr, channels_count);
+            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
         }
-        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
+        public void AddCallback(IntPtr callback, IntPtr callback_data)
         {
+            void* native_callback_data = (void*)callback_data.ToPointer();
+            ImGuiNative.ImDrawList_AddCallback(NativePtr, callback, native_callback_data);
+        }
+        public void AddCircle(Vector2 centre, float radius, uint col)
+        {
+            int num_segments = 12;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
+            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
         }
-        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col, float thickness)
+        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments)
         {
-            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
         }
-        public void AddPolyline(ref Vector2 points, int num_points, uint col, bool closed, float thickness)
+        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments, float thickness)
+        {
+            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+        }
+        public void AddCircleFilled(Vector2 centre, float radius, uint col)
+        {
+            int num_segments = 12;
+            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
+        }
+        public void AddCircleFilled(Vector2 centre, float radius, uint col, int num_segments)
+        {
+            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
+        }
+        public void AddConvexPolyFilled(ref Vector2 points, int num_points, uint col)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
             fixed (Vector2* native_points = &points)
             {
-                ImGuiNative.ImDrawList_AddPolyline(NativePtr, native_points, num_points, col, native_closed, thickness);
+                ImGuiNative.ImDrawList_AddConvexPolyFilled(NativePtr, native_points, num_points, col);
             }
         }
-        public void PopClipRect()
+        public void AddDrawCmd()
         {
-            ImGuiNative.ImDrawList_PopClipRect(NativePtr);
+            ImGuiNative.ImDrawList_AddDrawCmd(NativePtr);
         }
-        public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
+        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b)
         {
-            byte intersect_with_current_clip_rect = 0;
+            Vector2 uv_a = new Vector2();
-            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
+            Vector2 uv_b = new Vector2(1, 1);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
+        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a)
         {
-            byte native_intersect_with_current_clip_rect = intersect_with_current_clip_rect ? (byte)1 : (byte)0;
+            Vector2 uv_b = new Vector2(1, 1);
-            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3)
+        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b)
         {
-            int num_segments = 0;
+            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
+            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3, int num_segments)
+        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
         {
-            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
+            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void UpdateTextureID()
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d)
         {
-            ImGuiNative.ImDrawList_UpdateTextureID(NativePtr);
+            Vector2 uv_a = new Vector2();
+            Vector2 uv_b = new Vector2(1, 0);
+            Vector2 uv_c = new Vector2(1, 1);
+            Vector2 uv_d = new Vector2(0, 1);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void Clear()
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a)
         {
-            ImGuiNative.ImDrawList_Clear(NativePtr);
+            Vector2 uv_b = new Vector2(1, 0);
+            Vector2 uv_c = new Vector2(1, 1);
+            Vector2 uv_d = new Vector2(0, 1);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b)
         {
-            int num_segments = 0;
+            Vector2 uv_c = new Vector2(1, 1);
-            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
+            Vector2 uv_d = new Vector2(0, 1);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddBezierCurve(Vector2 pos0, Vector2 cp0, Vector2 cp1, Vector2 pos1, uint col, float thickness, int num_segments)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c)
         {
-            ImGuiNative.ImDrawList_AddBezierCurve(NativePtr, pos0, cp0, cp1, pos1, col, thickness, num_segments);
+            Vector2 uv_d = new Vector2(0, 1);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void PushTextureID(IntPtr texture_id)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d)
         {
-            ImGuiNative.ImDrawList_PushTextureID(NativePtr, texture_id);
+            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col)
+        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
         {
-            float rounding = 0.0f;
+            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding)
+        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding)
         {
-            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
+            int rounding_corners = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
         }
-        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags)
+        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding, int rounding_corners)
         {
-            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
         }
-        public void AddDrawCmd()
+        public void AddLine(Vector2 a, Vector2 b, uint col)
         {
-            ImGuiNative.ImDrawList_AddDrawCmd(NativePtr);
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
         }
-        public void UpdateClipRect()
+        public void AddLine(Vector2 a, Vector2 b, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_UpdateClipRect(NativePtr);
+            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
         }
-        public void PrimVtx(Vector2 pos, Vector2 uv, uint col)
+        public void AddPolyline(ref Vector2 points, int num_points, uint col, bool closed, float thickness)
         {
-            ImGuiNative.ImDrawList_PrimVtx(NativePtr, pos, uv, col);
+            byte native_closed = closed ? (byte)1 : (byte)0;
+            fixed (Vector2* native_points = &points)
+            {
+                ImGuiNative.ImDrawList_AddPolyline(NativePtr, native_points, num_points, col, native_closed, thickness);
+            }
         }
-        public void PrimRect(Vector2 a, Vector2 b, uint col)
+        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
         {
-            ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
+            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
         }
-        public void ClearFreeMemory()
+        public void AddQuad(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col, float thickness)
         {
-            ImGuiNative.ImDrawList_ClearFreeMemory(NativePtr);
+            ImGuiNative.ImDrawList_AddQuad(NativePtr, a, b, c, d, col, thickness);
         }
-        public ImDrawListPtr CloneOutput()
+        public void AddQuadFilled(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
         {
-            ImDrawList* ret = ImGuiNative.ImDrawList_CloneOutput(NativePtr);
+            ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, a, b, c, d, col);
-            return new ImDrawListPtr(ret);
         }
         public void AddRect(Vector2 a, Vector2 b, uint col)
         {
@@ -177,238 +217,198 @@ namespace ImGuiNET
         {
             ImGuiNative.ImDrawList_AddRect(NativePtr, a, b, col, rounding, rounding_corners_flags, thickness);
         }
-        public void AddCallback(IntPtr callback, IntPtr callback_data)
+        public void AddRectFilled(Vector2 a, Vector2 b, uint col)
-        {
-            void* native_callback_data = (void*)callback_data.ToPointer();
-            ImGuiNative.ImDrawList_AddCallback(NativePtr, callback, native_callback_data);
-        }
-        public void PathRect(Vector2 rect_min, Vector2 rect_max)
         {
             float rounding = 0.0f;
             int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
         }
-        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding)
+        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding)
         {
             int rounding_corners_flags = (int)ImDrawCornerFlags.All;
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
         }
-        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, int rounding_corners_flags)
+        public void AddRectFilled(Vector2 a, Vector2 b, uint col, float rounding, int rounding_corners_flags)
         {
-            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
+            ImGuiNative.ImDrawList_AddRectFilled(NativePtr, a, b, col, rounding, rounding_corners_flags);
         }
-        public void PathArcToFast(Vector2 centre, float radius, int a_min_of_12, int a_max_of_12)
+        public void AddRectFilledMultiColor(Vector2 a, Vector2 b, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
         {
-            ImGuiNative.ImDrawList_PathArcToFast(NativePtr, centre, radius, a_min_of_12, a_max_of_12);
+            ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, a, b, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
         }
-        public void PathStroke(uint col, bool closed)
+        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
+            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
         }
-        public void PathStroke(uint col, bool closed, float thickness)
+        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col, float thickness)
         {
-            byte native_closed = closed ? (byte)1 : (byte)0;
+            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
-            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
         }
-        public void PathFillConvex(uint col)
+        public void AddTriangleFilled(Vector2 a, Vector2 b, Vector2 c, uint col)
         {
-            ImGuiNative.ImDrawList_PathFillConvex(NativePtr, col);
+            ImGuiNative.ImDrawList_AddTriangleFilled(NativePtr, a, b, c, col);
         }
-        public void PathLineToMergeDuplicate(Vector2 pos)
+        public void ChannelsMerge()
         {
-            ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
+            ImGuiNative.ImDrawList_ChannelsMerge(NativePtr);
         }
-        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max)
+        public void ChannelsSetCurrent(int channel_index)
         {
-            int num_segments = 10;
+            ImGuiNative.ImDrawList_ChannelsSetCurrent(NativePtr, channel_index);
-            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
         }
-        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max, int num_segments)
+        public void ChannelsSplit(int channels_count)
         {
-            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
+            ImGuiNative.ImDrawList_ChannelsSplit(NativePtr, channels_count);
         }
-        public void AddConvexPolyFilled(ref Vector2 points, int num_points, uint col)
+        public void Clear()
         {
-            fixed (Vector2* native_points = &points)
+            ImGuiNative.ImDrawList_Clear(NativePtr);
-            {
-                ImGuiNative.ImDrawList_AddConvexPolyFilled(NativePtr, native_points, num_points, col);
-            }
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d)
+        public void ClearFreeMemory()
         {
-            Vector2 uv_a = new Vector2();
+            ImGuiNative.ImDrawList_ClearFreeMemory(NativePtr);
-            Vector2 uv_b = new Vector2(1, 0);
-            Vector2 uv_c = new Vector2(1, 1);
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a)
+        public ImDrawListPtr CloneOutput()
         {
-            Vector2 uv_b = new Vector2(1, 0);
+            ImDrawList* ret = ImGuiNative.ImDrawList_CloneOutput(NativePtr);
-            Vector2 uv_c = new Vector2(1, 1);
+            return new ImDrawListPtr(ret);
-            Vector2 uv_d = new Vector2(0, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b)
+        public Vector2 GetClipRectMax()
         {
-            Vector2 uv_c = new Vector2(1, 1);
+            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMax(NativePtr);
-            Vector2 uv_d = new Vector2(0, 1);
+            return ret;
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c)
+        public Vector2 GetClipRectMin()
         {
-            Vector2 uv_d = new Vector2(0, 1);
+            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMin(NativePtr);
-            uint col = 0xFFFFFFFF;
+            return ret;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d)
+        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max)
         {
-            uint col = 0xFFFFFFFF;
+            int num_segments = 10;
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
         }
-        public void AddImageQuad(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
+        public void PathArcTo(Vector2 centre, float radius, float a_min, float a_max, int num_segments)
         {
-            ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            ImGuiNative.ImDrawList_PathArcTo(NativePtr, centre, radius, a_min, a_max, num_segments);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b)
+        public void PathArcToFast(Vector2 centre, float radius, int a_min_of_12, int a_max_of_12)
         {
-            Vector2 uv_a = new Vector2();
+            ImGuiNative.ImDrawList_PathArcToFast(NativePtr, centre, radius, a_min_of_12, a_max_of_12);
-            Vector2 uv_b = new Vector2(1, 1);
-            uint col = 0xFFFFFFFF;
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a)
+        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3)
         {
-            Vector2 uv_b = new Vector2(1, 1);
+            int num_segments = 0;
-            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b)
+        public void PathBezierCurveTo(Vector2 p1, Vector2 p2, Vector2 p3, int num_segments)
         {
-            uint col = 0xFFFFFFFF;
+            ImGuiNative.ImDrawList_PathBezierCurveTo(NativePtr, p1, p2, p3, num_segments);
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
         }
-        public void AddImage(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
+        public void PathClear()
         {
-            ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, a, b, uv_a, uv_b, col);
+            ImGuiNative.ImDrawList_PathClear(NativePtr);
         }
-        public void AddCircleFilled(Vector2 centre, float radius, uint col)
+        public void PathFillConvex(uint col)
         {
-            int num_segments = 12;
+            ImGuiNative.ImDrawList_PathFillConvex(NativePtr, col);
-            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
         }
-        public void AddCircleFilled(Vector2 centre, float radius, uint col, int num_segments)
+        public void PathLineTo(Vector2 pos)
         {
-            ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, centre, radius, col, num_segments);
+            ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col)
+        public void PathLineToMergeDuplicate(Vector2 pos)
         {
-            int num_segments = 12;
+            ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
-            float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments)
+        public void PathRect(Vector2 rect_min, Vector2 rect_max)
         {
-            float thickness = 1.0f;
+            float rounding = 0.0f;
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
+            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
         }
-        public void AddCircle(Vector2 centre, float radius, uint col, int num_segments, float thickness)
+        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding)
         {
-            ImGuiNative.ImDrawList_AddCircle(NativePtr, centre, radius, col, num_segments, thickness);
+            int rounding_corners_flags = (int)ImDrawCornerFlags.All;
+            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
         }
-        public void AddTriangleFilled(Vector2 a, Vector2 b, Vector2 c, uint col)
+        public void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, int rounding_corners_flags)
         {
-            ImGuiNative.ImDrawList_AddTriangleFilled(NativePtr, a, b, c, col);
+            ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, rounding_corners_flags);
         }
-        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col)
+        public void PathStroke(uint col, bool closed)
         {
+            byte native_closed = closed ? (byte)1 : (byte)0;
             float thickness = 1.0f;
-            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
+            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
-        }
-        public void AddTriangle(Vector2 a, Vector2 b, Vector2 c, uint col, float thickness)
-        {
-            ImGuiNative.ImDrawList_AddTriangle(NativePtr, a, b, c, col, thickness);
-        }
-        public void AddQuadFilled(Vector2 a, Vector2 b, Vector2 c, Vector2 d, uint col)
-        {
-            ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, a, b, c, d, col);
-        }
-        public void PrimReserve(int idx_count, int vtx_count)
-        {
-            ImGuiNative.ImDrawList_PrimReserve(NativePtr, idx_count, vtx_count);
         }
-        public void AddRectFilledMultiColor(Vector2 a, Vector2 b, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
+        public void PathStroke(uint col, bool closed, float thickness)
         {
-            ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, a, b, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
+            byte native_closed = closed ? (byte)1 : (byte)0;
+            ImGuiNative.ImDrawList_PathStroke(NativePtr, col, native_closed, thickness);
         }
-        public void AddLine(Vector2 a, Vector2 b, uint col)
+        public void PopClipRect()
         {
-            float thickness = 1.0f;
+            ImGuiNative.ImDrawList_PopClipRect(NativePtr);
-            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
         }
-        public void AddLine(Vector2 a, Vector2 b, uint col, float thickness)
+        public void PopTextureID()
         {
-            ImGuiNative.ImDrawList_AddLine(NativePtr, a, b, col, thickness);
+            ImGuiNative.ImDrawList_PopTextureID(NativePtr);
         }
-        public Vector2 GetClipRectMin()
+        public void PrimQuadUV(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
         {
-            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMin(NativePtr);
+            ImGuiNative.ImDrawList_PrimQuadUV(NativePtr, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
-            return ret;
         }
-        public void PopTextureID()
+        public void PrimRect(Vector2 a, Vector2 b, uint col)
         {
-            ImGuiNative.ImDrawList_PopTextureID(NativePtr);
+            ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
         }
-        public void PrimWriteVtx(Vector2 pos, Vector2 uv, uint col)
+        public void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
         {
-            ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
+            ImGuiNative.ImDrawList_PrimRectUV(NativePtr, a, b, uv_a, uv_b, col);
         }
-        public Vector2 GetClipRectMax()
+        public void PrimReserve(int idx_count, int vtx_count)
         {
-            Vector2 ret = ImGuiNative.ImDrawList_GetClipRectMax(NativePtr);
+            ImGuiNative.ImDrawList_PrimReserve(NativePtr, idx_count, vtx_count);
-            return ret;
         }
-        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding)
+        public void PrimVtx(Vector2 pos, Vector2 uv, uint col)
         {
-            int rounding_corners = (int)ImDrawCornerFlags.All;
+            ImGuiNative.ImDrawList_PrimVtx(NativePtr, pos, uv, col);
-            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
         }
-        public void AddImageRounded(IntPtr user_texture_id, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col, float rounding, int rounding_corners)
+        public void PrimWriteIdx(ushort idx)
         {
-            ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, a, b, uv_a, uv_b, col, rounding, rounding_corners);
+            ImGuiNative.ImDrawList_PrimWriteIdx(NativePtr, idx);
         }
-        public void PrimQuadUV(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
+        public void PrimWriteVtx(Vector2 pos, Vector2 uv, uint col)
         {
-            ImGuiNative.ImDrawList_PrimQuadUV(NativePtr, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+            ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
         }
-        public void PathClear()
+        public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
         {
-            ImGuiNative.ImDrawList_PathClear(NativePtr);
+            byte intersect_with_current_clip_rect = 0;
+            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
         }
-        public void PrimWriteIdx(ushort idx)
+        public void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
         {
-            ImGuiNative.ImDrawList_PrimWriteIdx(NativePtr, idx);
+            byte native_intersect_with_current_clip_rect = intersect_with_current_clip_rect ? (byte)1 : (byte)0;
+            ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, native_intersect_with_current_clip_rect);
         }
         public void PushClipRectFullScreen()
         {
             ImGuiNative.ImDrawList_PushClipRectFullScreen(NativePtr);
         }
-        public void ChannelsMerge()
+        public void PushTextureID(IntPtr texture_id)
         {
-            ImGuiNative.ImDrawList_ChannelsMerge(NativePtr);
+            ImGuiNative.ImDrawList_PushTextureID(NativePtr, texture_id);
         }
-        public void PathLineTo(Vector2 pos)
+        public void UpdateClipRect()
         {
-            ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
+            ImGuiNative.ImDrawList_UpdateClipRect(NativePtr);
         }
-        public void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
+        public void UpdateTextureID()
         {
-            ImGuiNative.ImDrawList_PrimRectUV(NativePtr, a, b, uv_a, uv_b, col);
+            ImGuiNative.ImDrawList_UpdateTextureID(NativePtr);
         }
     }
 }

src/ImGui.NET/Generated/ImFont.gen.cs

@@ -48,9 +48,9 @@ namespace ImGuiNET
         public ref float Descent => ref Unsafe.AsRef<float>(&NativePtr->Descent);
         public ref bool DirtyLookupTables => ref Unsafe.AsRef<bool>(&NativePtr->DirtyLookupTables);
         public ref int MetricsTotalSurface => ref Unsafe.AsRef<int>(&NativePtr->MetricsTotalSurface);
-        public void GrowIndex(int new_size)
+        public void AddGlyph(ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
         {
-            ImGuiNative.ImFont_GrowIndex(NativePtr, new_size);
+            ImGuiNative.ImFont_AddGlyph(NativePtr, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
         }
         public void AddRemapChar(ushort dst, ushort src)
         {
@@ -62,51 +62,51 @@ namespace ImGuiNET
             byte native_overwrite_dst = overwrite_dst ? (byte)1 : (byte)0;
             ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, native_overwrite_dst);
         }
-        public void AddGlyph(ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
+        public void BuildLookupTable()
         {
-            ImGuiNative.ImFont_AddGlyph(NativePtr, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
+            ImGuiNative.ImFont_BuildLookupTable(NativePtr);
         }
-        public ImFontGlyphPtr FindGlyphNoFallback(ushort c)
+        public void ClearOutputData()
         {
-            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyphNoFallback(NativePtr, c);
+            ImGuiNative.ImFont_ClearOutputData(NativePtr);
+        }
+        public ImFontGlyphPtr FindGlyph(ushort c)
+        {
+            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyph(NativePtr, c);
             return new ImFontGlyphPtr(ret);
         }
-        public bool IsLoaded()
+        public ImFontGlyphPtr FindGlyphNoFallback(ushort c)
         {
-            byte ret = ImGuiNative.ImFont_IsLoaded(NativePtr);
+            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyphNoFallback(NativePtr, c);
-            return ret != 0;
+            return new ImFontGlyphPtr(ret);
         }
         public float GetCharAdvance(ushort c)
         {
             float ret = ImGuiNative.ImFont_GetCharAdvance(NativePtr, c);
             return ret;
         }
-        public void SetFallbackChar(ushort c)
+        public string GetDebugName()
-        {
-            ImGuiNative.ImFont_SetFallbackChar(NativePtr, c);
-        }
-        public void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
         {
-            ImDrawList* native_draw_list = draw_list.NativePtr;
+            byte* ret = ImGuiNative.ImFont_GetDebugName(NativePtr);
-            ImGuiNative.ImFont_RenderChar(NativePtr, native_draw_list, size, pos, col, c);
+            return Util.StringFromPtr(ret);
         }
-        public ImFontGlyphPtr FindGlyph(ushort c)
+        public void GrowIndex(int new_size)
         {
-            ImFontGlyph* ret = ImGuiNative.ImFont_FindGlyph(NativePtr, c);
+            ImGuiNative.ImFont_GrowIndex(NativePtr, new_size);
-            return new ImFontGlyphPtr(ret);
         }
-        public string GetDebugName()
+        public bool IsLoaded()
         {
-            byte* ret = ImGuiNative.ImFont_GetDebugName(NativePtr);
+            byte ret = ImGuiNative.ImFont_IsLoaded(NativePtr);
-            return Util.StringFromPtr(ret);
+            return ret != 0;
         }
-        public void BuildLookupTable()
+        public void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
         {
-            ImGuiNative.ImFont_BuildLookupTable(NativePtr);
+            ImDrawList* native_draw_list = draw_list.NativePtr;
+            ImGuiNative.ImFont_RenderChar(NativePtr, native_draw_list, size, pos, col, c);
         }
-        public void ClearOutputData()
+        public void SetFallbackChar(ushort c)
         {
-            ImGuiNative.ImFont_ClearOutputData(NativePtr);
+            ImGuiNative.ImFont_SetFallbackChar(NativePtr, c);
         }
     }
 }

src/ImGui.NET/Generated/ImFontAtlas.gen.cs

@@ -46,9 +46,101 @@ namespace ImGuiNET
         public ImVector<CustomRect> CustomRects => new ImVector<CustomRect>(NativePtr->CustomRects);
         public ImPtrVector<ImFontConfigPtr> ConfigData => new ImPtrVector<ImFontConfigPtr>(NativePtr->ConfigData, Unsafe.SizeOf<ImFontConfig>());
         public RangeAccessor<int> CustomRectIds => new RangeAccessor<int>(NativePtr->CustomRectIds, 1);
-        public void ClearFonts()
+        public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x)
         {
-            ImGuiNative.ImFontAtlas_ClearFonts(NativePtr);
+            ImFont* native_font = font.NativePtr;
+            Vector2 offset = new Vector2();
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
+            return ret;
+        }
+        public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x, Vector2 offset)
+        {
+            ImFont* native_font = font.NativePtr;
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
+            return ret;
+        }
+        public int AddCustomRectRegular(uint id, int width, int height)
+        {
+            int ret = ImGuiNative.ImFontAtlas_AddCustomRectRegular(NativePtr, id, width, height);
+            return ret;
+        }
+        public ImFontPtr AddFont(ImFontConfigPtr font_cfg)
+        {
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFont(NativePtr, native_font_cfg);
+            return new ImFontPtr(ret);
+        }
+        public ImFontPtr AddFontDefault()
+        {
+            ImFontConfig* font_cfg = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, font_cfg);
+            return new ImFontPtr(ret);
+        }
+        public ImFontPtr AddFontDefault(ImFontConfigPtr font_cfg)
+        {
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, native_font_cfg);
+            return new ImFontPtr(ret);
+        }
+        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
+        {
+            byte* native_filename;
+            if (filename != null)
+            {
+                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                native_filename = native_filename_stackBytes;
+                fixed (char* filename_ptr = filename)
+                {
+                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
+                    native_filename[native_filename_offset] = 0;
+                }
+            }
+            else { native_filename = null; }
+            ImFontConfig* font_cfg = null;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, font_cfg, glyph_ranges);
+            return new ImFontPtr(ret);
+        }
+        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg)
+        {
+            byte* native_filename;
+            if (filename != null)
+            {
+                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                native_filename = native_filename_stackBytes;
+                fixed (char* filename_ptr = filename)
+                {
+                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
+                    native_filename[native_filename_offset] = 0;
+                }
+            }
+            else { native_filename = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* glyph_ranges = null;
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, glyph_ranges);
+            return new ImFontPtr(ret);
+        }
+        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        {
+            byte* native_filename;
+            if (filename != null)
+            {
+                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
+                native_filename = native_filename_stackBytes;
+                fixed (char* filename_ptr = filename)
+                {
+                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
+                    native_filename[native_filename_offset] = 0;
+                }
+            }
+            else { native_filename = null; }
+            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
+            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, native_glyph_ranges);
+            return new ImFontPtr(ret);
         }
         public ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels)
         {
@@ -110,82 +202,6 @@ namespace ImGuiNET
             ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, native_compressed_font_data_base85, size_pixels, native_font_cfg, native_glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public bool Build()
-        {
-            byte ret = ImGuiNative.ImFontAtlas_Build(NativePtr);
-            return ret != 0;
-        }
-        public ImFontPtr AddFont(ImFontConfigPtr font_cfg)
-        {
-            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFont(NativePtr, native_font_cfg);
-            return new ImFontPtr(ret);
-        }
-        public void CalcCustomRectUV(ref CustomRect rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
-        {
-            fixed (CustomRect* native_rect = &rect)
-            {
-                fixed (Vector2* native_out_uv_min = &out_uv_min)
-                {
-                    fixed (Vector2* native_out_uv_max = &out_uv_max)
-                    {
-                        ImGuiNative.ImFontAtlas_CalcCustomRectUV(NativePtr, native_rect, native_out_uv_min, native_out_uv_max);
-                    }
-                }
-            }
-        }
-        public CustomRect* GetCustomRectByIndex(int index)
-        {
-            CustomRect* ret = ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index);
-            return ret;
-        }
-        public int AddCustomRectRegular(uint id, int width, int height)
-        {
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectRegular(NativePtr, id, width, height);
-            return ret;
-        }
-        public bool IsBuilt()
-        {
-            byte ret = ImGuiNative.ImFontAtlas_IsBuilt(NativePtr);
-            return ret != 0;
-        }
-        public IntPtr GetGlyphRangesThai()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
-            return (IntPtr)ret;
-        }
-        public IntPtr GetGlyphRangesCyrillic()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
-            return (IntPtr)ret;
-        }
-        public IntPtr GetGlyphRangesChineseSimplifiedCommon()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
-            return (IntPtr)ret;
-        }
-        public IntPtr GetGlyphRangesChineseFull()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
-            return (IntPtr)ret;
-        }
-        public IntPtr GetGlyphRangesDefault()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
-            return (IntPtr)ret;
-        }
-        public void SetTexID(IntPtr id)
-        {
-            ImGuiNative.ImFontAtlas_SetTexID(NativePtr, id);
-        }
-        public void ClearTexData()
-        {
-            ImGuiNative.ImFontAtlas_ClearTexData(NativePtr);
-        }
-        public void Clear()
-        {
-            ImGuiNative.ImFontAtlas_Clear(NativePtr);
-        }
         public ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels)
         {
             void* native_compressed_font_data = (void*)compressed_font_data.ToPointer();
@@ -234,83 +250,97 @@ namespace ImGuiNET
             ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, native_font_data, font_size, size_pixels, native_font_cfg, native_glyph_ranges);
             return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
+        public bool Build()
         {
-            byte* native_filename;
+            byte ret = ImGuiNative.ImFontAtlas_Build(NativePtr);
-            if (filename != null)
+            return ret != 0;
-            {
-                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
-                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
-                native_filename = native_filename_stackBytes;
-                fixed (char* filename_ptr = filename)
-                {
-                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
-                    native_filename[native_filename_offset] = 0;
-                }
-            }
-            else { native_filename = null; }
-            ImFontConfig* font_cfg = null;
-            ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, font_cfg, glyph_ranges);
-            return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg)
+        public void CalcCustomRectUV(ref CustomRect rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
         {
-            byte* native_filename;
+            fixed (CustomRect* native_rect = &rect)
-            if (filename != null)
             {
-                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
+                fixed (Vector2* native_out_uv_min = &out_uv_min)
-                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
-                native_filename = native_filename_stackBytes;
-                fixed (char* filename_ptr = filename)
                 {
-                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
+                    fixed (Vector2* native_out_uv_max = &out_uv_max)
-                    native_filename[native_filename_offset] = 0;
+                    {
+                        ImGuiNative.ImFontAtlas_CalcCustomRectUV(NativePtr, native_rect, native_out_uv_min, native_out_uv_max);
+                    }
                 }
             }
-            else { native_filename = null; }
-            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
-            ushort* glyph_ranges = null;
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, glyph_ranges);
-            return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
+        public void Clear()
         {
-            byte* native_filename;
+            ImGuiNative.ImFontAtlas_Clear(NativePtr);
-            if (filename != null)
-            {
-                int filename_byteCount = Encoding.UTF8.GetByteCount(filename);
-                byte* native_filename_stackBytes = stackalloc byte[filename_byteCount + 1];
-                native_filename = native_filename_stackBytes;
-                fixed (char* filename_ptr = filename)
-                {
-                    int native_filename_offset = Encoding.UTF8.GetBytes(filename_ptr, filename.Length, native_filename, filename_byteCount);
-                    native_filename[native_filename_offset] = 0;
-                }
-            }
-            else { native_filename = null; }
-            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
-            ushort* native_glyph_ranges = (ushort*)glyph_ranges.ToPointer();
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, native_filename, size_pixels, native_font_cfg, native_glyph_ranges);
-            return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontDefault()
+        public void ClearFonts()
         {
-            ImFontConfig* font_cfg = null;
+            ImGuiNative.ImFontAtlas_ClearFonts(NativePtr);
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, font_cfg);
-            return new ImFontPtr(ret);
         }
-        public ImFontPtr AddFontDefault(ImFontConfigPtr font_cfg)
+        public void ClearInputData()
         {
-            ImFontConfig* native_font_cfg = font_cfg.NativePtr;
+            ImGuiNative.ImFontAtlas_ClearInputData(NativePtr);
-            ImFont* ret = ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, native_font_cfg);
+        }
-            return new ImFontPtr(ret);
+        public void ClearTexData()
+        {
+            ImGuiNative.ImFontAtlas_ClearTexData(NativePtr);
+        }
+        public CustomRect* GetCustomRectByIndex(int index)
+        {
+            CustomRect* ret = ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index);
+            return ret;
+        }
+        public IntPtr GetGlyphRangesChineseFull()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesChineseSimplifiedCommon()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesCyrillic()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesDefault()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
+            return (IntPtr)ret;
         }
         public IntPtr GetGlyphRangesJapanese()
         {
             ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(NativePtr);
             return (IntPtr)ret;
         }
+        public IntPtr GetGlyphRangesKorean()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
+            return (IntPtr)ret;
+        }
+        public IntPtr GetGlyphRangesThai()
+        {
+            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
+            return (IntPtr)ret;
+        }
+        public bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offset, out Vector2 out_size, out Vector2 out_uv_border, out Vector2 out_uv_fill)
+        {
+            fixed (Vector2* native_out_offset = &out_offset)
+            {
+                fixed (Vector2* native_out_size = &out_size)
+                {
+                    fixed (Vector2* native_out_uv_border = &out_uv_border)
+                    {
+                        fixed (Vector2* native_out_uv_fill = &out_uv_fill)
+                        {
+                            byte ret = ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, native_out_offset, native_out_size, native_out_uv_border, native_out_uv_fill);
+                            return ret != 0;
+                        }
+                    }
+                }
+            }
+        }
         public void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int out_height)
         {
             int* out_bytes_per_pixel = null;
@@ -341,32 +371,6 @@ namespace ImGuiNET
                 }
             }
         }
-        public void ClearInputData()
-        {
-            ImGuiNative.ImFontAtlas_ClearInputData(NativePtr);
-        }
-        public bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offset, out Vector2 out_size, out Vector2 out_uv_border, out Vector2 out_uv_fill)
-        {
-            fixed (Vector2* native_out_offset = &out_offset)
-            {
-                fixed (Vector2* native_out_size = &out_size)
-                {
-                    fixed (Vector2* native_out_uv_border = &out_uv_border)
-                    {
-                        fixed (Vector2* native_out_uv_fill = &out_uv_fill)
-                        {
-                            byte ret = ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, native_out_offset, native_out_size, native_out_uv_border, native_out_uv_fill);
-                            return ret != 0;
-                        }
-                    }
-                }
-            }
-        }
-        public IntPtr GetGlyphRangesKorean()
-        {
-            ushort* ret = ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
-            return (IntPtr)ret;
-        }
         public void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height)
         {
             int* out_bytes_per_pixel = null;
@@ -397,18 +401,14 @@ namespace ImGuiNET
                 }
             }
         }
-        public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x)
+        public bool IsBuilt()
         {
-            ImFont* native_font = font.NativePtr;
+            byte ret = ImGuiNative.ImFontAtlas_IsBuilt(NativePtr);
-            Vector2 offset = new Vector2();
+            return ret != 0;
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
-            return ret;
         }
-        public int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x, Vector2 offset)
+        public void SetTexID(IntPtr id)
         {
-            ImFont* native_font = font.NativePtr;
+            ImGuiNative.ImFontAtlas_SetTexID(NativePtr, id);
-            int ret = ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, native_font, id, width, height, advance_x, offset);
-            return ret;
         }
     }
 }

src/ImGui.NET/Generated/ImGuiIO.gen.cs

@@ -166,6 +166,10 @@ namespace ImGuiNET
         public RangeAccessor<float> KeysDownDurationPrev => new RangeAccessor<float>(NativePtr->KeysDownDurationPrev, 512);
         public RangeAccessor<float> NavInputsDownDuration => new RangeAccessor<float>(NativePtr->NavInputsDownDuration, 21);
         public RangeAccessor<float> NavInputsDownDurationPrev => new RangeAccessor<float>(NativePtr->NavInputsDownDurationPrev, 21);
+        public void AddInputCharacter(ushort c)
+        {
+            ImGuiNative.ImGuiIO_AddInputCharacter(NativePtr, c);
+        }
         public void AddInputCharactersUTF8(string utf8_chars)
         {
             byte* native_utf8_chars;
@@ -187,9 +191,5 @@ namespace ImGuiNET
         {
             ImGuiNative.ImGuiIO_ClearInputCharacters(NativePtr);
         }
-        public void AddInputCharacter(ushort c)
-        {
-            ImGuiNative.ImGuiIO_AddInputCharacter(NativePtr, c);
-        }
     }
 }

src/ImGui.NET/Generated/ImGuiListClipper.gen.cs

@@ -28,10 +28,6 @@ namespace ImGuiNET
         public ref int StepNo => ref Unsafe.AsRef<int>(&NativePtr->StepNo);
         public ref int DisplayStart => ref Unsafe.AsRef<int>(&NativePtr->DisplayStart);
         public ref int DisplayEnd => ref Unsafe.AsRef<int>(&NativePtr->DisplayEnd);
-        public void End()
-        {
-            ImGuiNative.ImGuiListClipper_End(NativePtr);
-        }
         public void Begin(int items_count)
         {
             float items_height = -1.0f;
@@ -41,6 +37,10 @@ namespace ImGuiNET
         {
             ImGuiNative.ImGuiListClipper_Begin(NativePtr, items_count, items_height);
         }
+        public void End()
+        {
+            ImGuiNative.ImGuiListClipper_End(NativePtr);
+        }
         public bool Step()
         {
             byte ret = ImGuiNative.ImGuiListClipper_Step(NativePtr);

src/ImGui.NET/Generated/ImGuiPayload.gen.cs

@@ -36,11 +36,6 @@ namespace ImGuiNET
         {
             ImGuiNative.ImGuiPayload_Clear(NativePtr);
         }
-        public bool IsPreview()
-        {
-            byte ret = ImGuiNative.ImGuiPayload_IsPreview(NativePtr);
-            return ret != 0;
-        }
         public bool IsDataType(string type)
         {
             byte* native_type;
@@ -64,5 +59,10 @@ namespace ImGuiNET
             byte ret = ImGuiNative.ImGuiPayload_IsDelivery(NativePtr);
             return ret != 0;
         }
+        public bool IsPreview()
+        {
+            byte ret = ImGuiNative.ImGuiPayload_IsPreview(NativePtr);
+            return ret != 0;
+        }
     }
 }

src/ImGui.NET/Generated/ImGuiStorage.gen.cs

@@ -18,26 +18,48 @@ namespace ImGuiNET
         public static implicit operator ImGuiStorage* (ImGuiStoragePtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiStoragePtr(IntPtr nativePtr) => new ImGuiStoragePtr(nativePtr);
         public ImVector<Pair> Data => new ImVector<Pair>(NativePtr->Data);
-        public void** GetVoidPtrRef(uint key)
+        public void BuildSortByKey()
         {
-            void* default_val = null;
+            ImGuiNative.ImGuiStorage_BuildSortByKey(NativePtr);
-            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, default_val);
+        }
+        public void Clear()
+        {
+            ImGuiNative.ImGuiStorage_Clear(NativePtr);
+        }
+        public bool GetBool(uint key)
+        {
+            byte default_val = 0;
+            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val);
+            return ret != 0;
+        }
+        public bool GetBool(uint key, bool default_val)
+        {
+            byte native_default_val = default_val ? (byte)1 : (byte)0;
+            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, native_default_val);
+            return ret != 0;
+        }
+        public byte* GetBoolRef(uint key)
+        {
+            byte default_val = 0;
+            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, default_val);
             return ret;
         }
-        public void** GetVoidPtrRef(uint key, IntPtr default_val)
+        public byte* GetBoolRef(uint key, bool default_val)
         {
-            void* native_default_val = (void*)default_val.ToPointer();
+            byte native_default_val = default_val ? (byte)1 : (byte)0;
-            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, native_default_val);
+            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, native_default_val);
             return ret;
         }
-        public void SetFloat(uint key, float val)
+        public float GetFloat(uint key)
         {
-            ImGuiNative.ImGuiStorage_SetFloat(NativePtr, key, val);
+            float default_val = 0.0f;
+            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
+            return ret;
         }
-        public IntPtr GetVoidPtr(uint key)
+        public float GetFloat(uint key, float default_val)
         {
-            void* ret = ImGuiNative.ImGuiStorage_GetVoidPtr(NativePtr, key);
+            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
-            return (IntPtr)ret;
+            return ret;
         }
         public float* GetFloatRef(uint key)
         {
@@ -50,20 +72,15 @@ namespace ImGuiNET
             float* ret = ImGuiNative.ImGuiStorage_GetFloatRef(NativePtr, key, default_val);
             return ret;
         }
-        public void SetAllInt(int val)
+        public int GetInt(uint key)
-        {
-            ImGuiNative.ImGuiStorage_SetAllInt(NativePtr, val);
-        }
-        public byte* GetBoolRef(uint key)
         {
-            byte default_val = 0;
+            int default_val = 0;
-            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, default_val);
+            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
             return ret;
         }
-        public byte* GetBoolRef(uint key, bool default_val)
+        public int GetInt(uint key, int default_val)
         {
-            byte native_default_val = default_val ? (byte)1 : (byte)0;
+            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
-            byte* ret = ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, native_default_val);
             return ret;
         }
         public int* GetIntRef(uint key)
@@ -77,61 +94,44 @@ namespace ImGuiNET
             int* ret = ImGuiNative.ImGuiStorage_GetIntRef(NativePtr, key, default_val);
             return ret;
         }
-        public void SetVoidPtr(uint key, IntPtr val)
+        public IntPtr GetVoidPtr(uint key)
         {
-            void* native_val = (void*)val.ToPointer();
+            void* ret = ImGuiNative.ImGuiStorage_GetVoidPtr(NativePtr, key);
-            ImGuiNative.ImGuiStorage_SetVoidPtr(NativePtr, key, native_val);
+            return (IntPtr)ret;
         }
-        public void BuildSortByKey()
+        public void** GetVoidPtrRef(uint key)
         {
-            ImGuiNative.ImGuiStorage_BuildSortByKey(NativePtr);
+            void* default_val = null;
+            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, default_val);
+            return ret;
         }
-        public float GetFloat(uint key)
+        public void** GetVoidPtrRef(uint key, IntPtr default_val)
         {
-            float default_val = 0.0f;
+            void* native_default_val = (void*)default_val.ToPointer();
-            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
+            void** ret = ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, native_default_val);
             return ret;
         }
-        public float GetFloat(uint key, float default_val)
+        public void SetAllInt(int val)
         {
-            float ret = ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
+            ImGuiNative.ImGuiStorage_SetAllInt(NativePtr, val);
-            return ret;
         }
         public void SetBool(uint key, bool val)
         {
             byte native_val = val ? (byte)1 : (byte)0;
             ImGuiNative.ImGuiStorage_SetBool(NativePtr, key, native_val);
         }
-        public bool GetBool(uint key)
+        public void SetFloat(uint key, float val)
-        {
-            byte default_val = 0;
-            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val);
-            return ret != 0;
-        }
-        public bool GetBool(uint key, bool default_val)
         {
-            byte native_default_val = default_val ? (byte)1 : (byte)0;
+            ImGuiNative.ImGuiStorage_SetFloat(NativePtr, key, val);
-            byte ret = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, native_default_val);
-            return ret != 0;
         }
         public void SetInt(uint key, int val)
         {
             ImGuiNative.ImGuiStorage_SetInt(NativePtr, key, val);
         }
-        public void Clear()
+        public void SetVoidPtr(uint key, IntPtr val)
-        {
-            ImGuiNative.ImGuiStorage_Clear(NativePtr);
-        }
-        public int GetInt(uint key)
-        {
-            int default_val = 0;
-            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
-            return ret;
-        }
-        public int GetInt(uint key, int default_val)
         {
-            int ret = ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
+            void* native_val = (void*)val.ToPointer();
-            return ret;
+            ImGuiNative.ImGuiStorage_SetVoidPtr(NativePtr, key, native_val);
         }
     }
 }

src/ImGui.NET/Generated/ImGuiTextBuffer.gen.cs

@@ -18,15 +18,6 @@ namespace ImGuiNET
         public static implicit operator ImGuiTextBuffer* (ImGuiTextBufferPtr wrappedPtr) => wrappedPtr.NativePtr;
         public static implicit operator ImGuiTextBufferPtr(IntPtr nativePtr) => new ImGuiTextBufferPtr(nativePtr);
         public ImVector<byte> Buf => new ImVector<byte>(NativePtr->Buf);
-        public bool empty()
-        {
-            byte ret = ImGuiNative.ImGuiTextBuffer_empty(NativePtr);
-            return ret != 0;
-        }
-        public void clear()
-        {
-            ImGuiNative.ImGuiTextBuffer_clear(NativePtr);
-        }
         public void appendf(string fmt)
         {
             byte* native_fmt;
@@ -44,29 +35,38 @@ namespace ImGuiNET
             else { native_fmt = null; }
             ImGuiNative.ImGuiTextBuffer_appendf(NativePtr, native_fmt);
         }
-        public string c_str()
+        public string begin()
         {
-            byte* ret = ImGuiNative.ImGuiTextBuffer_c_str(NativePtr);
+            byte* ret = ImGuiNative.ImGuiTextBuffer_begin(NativePtr);
             return Util.StringFromPtr(ret);
         }
-        public void reserve(int capacity)
+        public string c_str()
         {
-            ImGuiNative.ImGuiTextBuffer_reserve(NativePtr, capacity);
+            byte* ret = ImGuiNative.ImGuiTextBuffer_c_str(NativePtr);
+            return Util.StringFromPtr(ret);
         }
-        public int size()
+        public void clear()
         {
-            int ret = ImGuiNative.ImGuiTextBuffer_size(NativePtr);
+            ImGuiNative.ImGuiTextBuffer_clear(NativePtr);
-            return ret;
         }
-        public string begin()
+        public bool empty()
         {
-            byte* ret = ImGuiNative.ImGuiTextBuffer_begin(NativePtr);
+            byte ret = ImGuiNative.ImGuiTextBuffer_empty(NativePtr);
-            return Util.StringFromPtr(ret);
+            return ret != 0;
         }
         public string end()
         {
             byte* ret = ImGuiNative.ImGuiTextBuffer_end(NativePtr);
             return Util.StringFromPtr(ret);
         }
+        public void reserve(int capacity)
+        {
+            ImGuiNative.ImGuiTextBuffer_reserve(NativePtr, capacity);
+        }
+        public int size()
+        {
+            int ret = ImGuiNative.ImGuiTextBuffer_size(NativePtr);
+            return ret;
+        }
     }
 }

src/ImGui.NET/Generated/ImGuiTextFilter.gen.cs

@@ -26,6 +26,10 @@ namespace ImGuiNET
         {
             ImGuiNative.ImGuiTextFilter_Build(NativePtr);
         }
+        public void Clear()
+        {
+            ImGuiNative.ImGuiTextFilter_Clear(NativePtr);
+        }
         public bool Draw()
         {
             byte* native_label;
@@ -83,10 +87,6 @@ namespace ImGuiNET
             byte ret = ImGuiNative.ImGuiTextFilter_IsActive(NativePtr);
             return ret != 0;
         }
-        public void Clear()
-        {
-            ImGuiNative.ImGuiTextFilter_Clear(NativePtr);
-        }
         public bool PassFilter(string text)
         {
             byte* native_text;

src/ImGui.NET/Generated/TextRange.gen.cs

@@ -20,18 +20,6 @@ namespace ImGuiNET
         public static implicit operator TextRangePtr(IntPtr nativePtr) => new TextRangePtr(nativePtr);
         public IntPtr b { get => (IntPtr)NativePtr->b; set => NativePtr->b = (byte*)value; }
         public IntPtr e { get => (IntPtr)NativePtr->e; set => NativePtr->e = (byte*)value; }
-        public void split(byte separator, out ImVector @out)
-        {
-            fixed (ImVector* native_out = &@out)
-            {
-                ImGuiNative.TextRange_split(NativePtr, separator, native_out);
-            }
-        }
-        public string end()
-        {
-            byte* ret = ImGuiNative.TextRange_end(NativePtr);
-            return Util.StringFromPtr(ret);
-        }
         public string begin()
         {
             byte* ret = ImGuiNative.TextRange_begin(NativePtr);
@@ -42,5 +30,17 @@ namespace ImGuiNET
             byte ret = ImGuiNative.TextRange_empty(NativePtr);
             return ret != 0;
         }
+        public string end()
+        {
+            byte* ret = ImGuiNative.TextRange_end(NativePtr);
+            return Util.StringFromPtr(ret);
+        }
+        public void split(byte separator, out ImVector @out)
+        {
+            fixed (ImVector* native_out = &@out)
+            {
+                ImGuiNative.TextRange_split(NativePtr, separator, native_out);
+            }
+        }
     }
 }