packages feed

dear-imgui-raw-internal-1.0.0: cbits/DearImGuiWrappers.cpp

// Generated by dear-bindings-ffi. Do not edit.
#include "DearImGuiWrappers.h"

extern "C" void cImBezierCubicCalc_wrap(ImVec2 const* p1, ImVec2 const* p2, ImVec2 const* p3, ImVec2 const* p4, float t, ImVec2* _out) {
    *_out = cImBezierCubicCalc(*p1, *p2, *p3, *p4, t);
}

extern "C" void cImBezierCubicClosestPoint_wrap(ImVec2 const* p1, ImVec2 const* p2, ImVec2 const* p3, ImVec2 const* p4, ImVec2 const* p, int num_segments, ImVec2* _out) {
    *_out = cImBezierCubicClosestPoint(*p1, *p2, *p3, *p4, *p, num_segments);
}

extern "C" void cImBezierCubicClosestPointCasteljau_wrap(ImVec2 const* p1, ImVec2 const* p2, ImVec2 const* p3, ImVec2 const* p4, ImVec2 const* p, float max_error, ImVec2* _out) {
    *_out = cImBezierCubicClosestPointCasteljau(*p1, *p2, *p3, *p4, *p, max_error);
}

extern "C" void cImBezierQuadraticCalc_wrap(ImVec2 const* p1, ImVec2 const* p2, ImVec2 const* p3, float t, ImVec2* _out) {
    *_out = cImBezierQuadraticCalc(*p1, *p2, *p3, t);
}

extern "C" void cImClampImVec2_wrap(ImVec2 const* v, ImVec2 const* mn, ImVec2 const* mx, ImVec2* _out) {
    *_out = cImClampImVec2(*v, *mn, *mx);
}

extern "C" float cImDot_wrap(ImVec2 const* a, ImVec2 const* b) {
    return cImDot(*a, *b);
}

extern "C" void cImFloorImVec2_wrap(ImVec2 const* v, ImVec2* _out) {
    *_out = cImFloorImVec2(*v);
}

extern "C" void cImFontAtlasTextureGetSizeEstimate_wrap(ImFontAtlas* atlas, ImVec2i* _out) {
    *_out = cImFontAtlasTextureGetSizeEstimate(atlas);
}

extern "C" void cImFontAtlasUpdateDrawListsTextures_wrap(ImFontAtlas* atlas, ImTextureRef const* old_tex, ImTextureRef const* new_tex) {
    cImFontAtlasUpdateDrawListsTextures(atlas, *old_tex, *new_tex);
}

extern "C" void cImFontCalcTextSizeEx_wrap(ImFont* font, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining, ImVec2* out_offset, ImDrawTextFlags flags, ImVec2* _out) {
    *_out = cImFontCalcTextSizeEx(font, size, max_width, wrap_width, text_begin, text_end_display, text_end, out_remaining, out_offset, flags);
}

extern "C" float cImInvLength_wrap(ImVec2 const* lhs, float fail_value) {
    return cImInvLength(*lhs, fail_value);
}

extern "C" float cImLengthSqr_wrap(ImVec2 const* lhs) {
    return cImLengthSqr(*lhs);
}

extern "C" float cImLengthSqrImVec4_wrap(ImVec4 const* lhs) {
    return cImLengthSqrImVec4(*lhs);
}

extern "C" void cImLerp_wrap(ImVec2 const* a, ImVec2 const* b, float t, ImVec2* _out) {
    *_out = cImLerp(*a, *b, t);
}

extern "C" void cImLerpImVec2_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* t, ImVec2* _out) {
    *_out = cImLerpImVec2(*a, *b, *t);
}

extern "C" void cImLerpImVec4_wrap(ImVec4 const* a, ImVec4 const* b, float t, ImVec4* _out) {
    *_out = cImLerpImVec4(*a, *b, t);
}

extern "C" void cImLineClosestPoint_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* p, ImVec2* _out) {
    *_out = cImLineClosestPoint(*a, *b, *p);
}

extern "C" void cImMaxImVec2_wrap(ImVec2 const* lhs, ImVec2 const* rhs, ImVec2* _out) {
    *_out = cImMaxImVec2(*lhs, *rhs);
}

extern "C" void cImMinImVec2_wrap(ImVec2 const* lhs, ImVec2 const* rhs, ImVec2* _out) {
    *_out = cImMinImVec2(*lhs, *rhs);
}

extern "C" void cImMul_wrap(ImVec2 const* lhs, ImVec2 const* rhs, ImVec2* _out) {
    *_out = cImMul(*lhs, *rhs);
}

extern "C" void cImRotate_wrap(ImVec2 const* v, float cos_a, float sin_a, ImVec2* _out) {
    *_out = cImRotate(*v, cos_a, sin_a);
}

extern "C" float cImTriangleArea_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* c) {
    return cImTriangleArea(*a, *b, *c);
}

extern "C" void cImTriangleBarycentricCoords_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* c, ImVec2 const* p, float* out_u, float* out_v, float* out_w) {
    cImTriangleBarycentricCoords(*a, *b, *c, *p, out_u, out_v, out_w);
}

extern "C" void cImTriangleClosestPoint_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* c, ImVec2 const* p, ImVec2* _out) {
    *_out = cImTriangleClosestPoint(*a, *b, *c, *p);
}

extern "C" bool cImTriangleContainsPoint_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* c, ImVec2 const* p) {
    return cImTriangleContainsPoint(*a, *b, *c, *p);
}

extern "C" bool cImTriangleIsClockwise_wrap(ImVec2 const* a, ImVec2 const* b, ImVec2 const* c) {
    return cImTriangleIsClockwise(*a, *b, *c);
}

extern "C" void cImTruncImVec2_wrap(ImVec2 const* v, ImVec2* _out) {
    *_out = cImTruncImVec2(*v);
}

extern "C" bool ImGui_ArrowButtonEx_wrap(const char* str_id, ImGuiDir dir, ImVec2 const* size_arg, ImGuiButtonFlags flags) {
    return ImGui_ArrowButtonEx(str_id, dir, *size_arg, flags);
}

extern "C" bool ImGui_BeginBoxSelect_wrap(ImRect const* scope_rect, ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags) {
    return ImGui_BeginBoxSelect(*scope_rect, window, box_select_id, ms_flags);
}

extern "C" bool ImGui_BeginChildEx_wrap(const char* name, ImGuiID id, ImVec2 const* size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags) {
    return ImGui_BeginChildEx(name, id, *size_arg, child_flags, window_flags);
}

extern "C" bool ImGui_BeginComboPopup_wrap(ImGuiID popup_id, ImRect const* bb, ImGuiComboFlags flags) {
    return ImGui_BeginComboPopup(popup_id, *bb, flags);
}

extern "C" bool ImGui_BeginDragDropTargetCustom_wrap(ImRect const* bb, ImGuiID id) {
    return ImGui_BeginDragDropTargetCustom(*bb, id);
}

extern "C" bool ImGui_BeginTabBarEx_wrap(ImGuiTabBar* tab_bar, ImRect const* bb, ImGuiTabBarFlags flags) {
    return ImGui_BeginTabBarEx(tab_bar, *bb, flags);
}

extern "C" bool ImGui_BeginTableWithID_wrap(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, ImVec2 const* outer_size, float inner_width) {
    return ImGui_BeginTableWithID(name, id, columns_count, flags, *outer_size, inner_width);
}

extern "C" bool ImGui_ButtonBehavior_wrap(ImRect const* bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags) {
    return ImGui_ButtonBehavior(*bb, id, out_hovered, out_held, flags);
}

extern "C" bool ImGui_ButtonWithFlags_wrap(const char* label, ImVec2 const* size_arg, ImGuiButtonFlags flags) {
    return ImGui_ButtonWithFlags(label, *size_arg, flags);
}

extern "C" void ImGui_CalcClipRectVisibleItemsY_wrap(ImRect const* clip_rect, ImVec2 const* pos, float items_height, int* out_visible_start, int* out_visible_end) {
    ImGui_CalcClipRectVisibleItemsY(*clip_rect, *pos, items_height, out_visible_start, out_visible_end);
}

extern "C" void ImGui_CalcItemSize_wrap(ImVec2 const* size, float default_w, float default_h, ImVec2* _out) {
    *_out = ImGui_CalcItemSize(*size, default_w, default_h);
}

extern "C" ImDrawFlags ImGui_CalcRoundingFlagsForRectInRect_wrap(ImRect const* r_in, ImRect const* r_outer, float threshold) {
    return ImGui_CalcRoundingFlagsForRectInRect(*r_in, *r_outer, threshold);
}

extern "C" void ImGui_CalcWindowNextAutoFitSize_wrap(ImGuiWindow* window, ImVec2* _out) {
    *_out = ImGui_CalcWindowNextAutoFitSize(window);
}

extern "C" float ImGui_CalcWrapWidthForPos_wrap(ImVec2 const* pos, float wrap_pos_x) {
    return ImGui_CalcWrapWidthForPos(*pos, wrap_pos_x);
}

extern "C" bool ImGui_CloseButton_wrap(ImGuiID id, ImVec2 const* pos) {
    return ImGui_CloseButton(id, *pos);
}

extern "C" bool ImGui_CollapseButton_wrap(ImGuiID id, ImVec2 const* pos, ImGuiDockNode* dock_node) {
    return ImGui_CollapseButton(id, *pos, dock_node);
}

extern "C" void ImGui_DebugRenderViewportThumbnail_wrap(ImDrawList* draw_list, ImGuiViewportP* viewport, ImRect const* bb) {
    ImGui_DebugRenderViewportThumbnail(draw_list, viewport, *bb);
}

extern "C" void ImGui_DockBuilderSetNodePos_wrap(ImGuiID node_id, ImVec2 const* pos) {
    ImGui_DockBuilderSetNodePos(node_id, *pos);
}

extern "C" void ImGui_DockBuilderSetNodeSize_wrap(ImGuiID node_id, ImVec2 const* size) {
    ImGui_DockBuilderSetNodeSize(node_id, *size);
}

extern "C" void ImGui_EndBoxSelect_wrap(ImRect const* scope_rect, ImGuiMultiSelectFlags ms_flags) {
    ImGui_EndBoxSelect(*scope_rect, ms_flags);
}

extern "C" void ImGui_FindBestWindowPosForPopup_wrap(ImGuiWindow* window, ImVec2* _out) {
    *_out = ImGui_FindBestWindowPosForPopup(window);
}

extern "C" void ImGui_FindBestWindowPosForPopupEx_wrap(ImVec2 const* ref_pos, ImVec2 const* size, ImGuiDir* last_dir, ImRect const* r_outer, ImRect const* r_avoid, ImGuiPopupPositionPolicy policy, ImVec2* _out) {
    *_out = ImGui_FindBestWindowPosForPopupEx(*ref_pos, *size, last_dir, *r_outer, *r_avoid, policy);
}

extern "C" ImGuiViewportP* ImGui_FindHoveredViewportFromPlatformWindowStack_wrap(ImVec2 const* mouse_platform_pos) {
    return ImGui_FindHoveredViewportFromPlatformWindowStack(*mouse_platform_pos);
}

extern "C" void ImGui_FindHoveredWindowEx_wrap(ImVec2 const* pos, bool find_first_and_in_any_viewport, ImGuiWindow** out_hovered_window, ImGuiWindow** out_hovered_window_under_moving_window) {
    ImGui_FindHoveredWindowEx(*pos, find_first_and_in_any_viewport, out_hovered_window, out_hovered_window_under_moving_window);
}

extern "C" void ImGui_GetKeyMagnitude2d_wrap(ImGuiKey key_left, ImGuiKey key_right, ImGuiKey key_up, ImGuiKey key_down, ImVec2* _out) {
    *_out = ImGui_GetKeyMagnitude2d(key_left, key_right, key_up, key_down);
}

extern "C" void ImGui_GetPopupAllowedExtentRect_wrap(ImGuiWindow* window, ImRect* _out) {
    *_out = ImGui_GetPopupAllowedExtentRect(window);
}

extern "C" void ImGui_GetWindowScrollbarRect_wrap(ImGuiWindow* window, ImGuiAxis axis, ImRect* _out) {
    *_out = ImGui_GetWindowScrollbarRect(window, axis);
}

extern "C" bool ImGui_ImageButtonWithFlags_wrap(ImGuiID id, ImTextureRef const* tex_ref, ImVec2 const* image_size, ImVec2 const* uv0, ImVec2 const* uv1, ImVec4 const* bg_col, ImVec4 const* tint_col, ImGuiButtonFlags flags) {
    return ImGui_ImageButtonWithFlags(id, *tex_ref, *image_size, *uv0, *uv1, *bg_col, *tint_col, flags);
}

extern "C" bool ImGui_InputTextWithHintAndSize_wrap(const char* label, const char* hint, char* buf, int buf_size, ImVec2 const* size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) {
    return ImGui_InputTextWithHintAndSize(label, hint, buf, buf_size, *size_arg, flags, callback, user_data);
}

extern "C" bool ImGui_IsClippedEx_wrap(ImRect const* bb, ImGuiID id) {
    return ImGui_IsClippedEx(*bb, id);
}

extern "C" bool ImGui_ItemAdd_wrap(ImRect const* bb, ImGuiID id, const ImRect* nav_bb, ImGuiItemFlags extra_flags) {
    return ImGui_ItemAdd(*bb, id, nav_bb, extra_flags);
}

extern "C" bool ImGui_ItemHoverable_wrap(ImRect const* bb, ImGuiID id, ImGuiItemFlags item_flags) {
    return ImGui_ItemHoverable(*bb, id, item_flags);
}

extern "C" void ImGui_ItemSize_wrap(ImVec2 const* size, float text_baseline_y) {
    ImGui_ItemSize(*size, text_baseline_y);
}

extern "C" void ImGui_ItemSizeImRect_wrap(ImRect const* bb, float text_baseline_y) {
    ImGui_ItemSizeImRect(*bb, text_baseline_y);
}

extern "C" int ImGui_PlotEx_wrap(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 const* size_arg) {
    return ImGui_PlotEx(plot_type, label, values_getter, data, values_count, values_offset, overlay_text, scale_min, scale_max, *size_arg);
}

extern "C" void ImGui_RenderArrow_wrap(ImDrawList* draw_list, ImVec2 const* pos, ImU32 col, ImGuiDir dir, float scale) {
    ImGui_RenderArrow(draw_list, *pos, col, dir, scale);
}

extern "C" void ImGui_RenderArrowDockMenu_wrap(ImDrawList* draw_list, ImVec2 const* p_min, float sz, ImU32 col) {
    ImGui_RenderArrowDockMenu(draw_list, *p_min, sz, col);
}

extern "C" void ImGui_RenderArrowPointingAt_wrap(ImDrawList* draw_list, ImVec2 const* pos, ImVec2 const* half_sz, ImGuiDir direction, ImU32 col) {
    ImGui_RenderArrowPointingAt(draw_list, *pos, *half_sz, direction, col);
}

extern "C" void ImGui_RenderBullet_wrap(ImDrawList* draw_list, ImVec2 const* pos, ImU32 col) {
    ImGui_RenderBullet(draw_list, *pos, col);
}

extern "C" void ImGui_RenderCheckMark_wrap(ImDrawList* draw_list, ImVec2 const* pos, ImU32 col, float sz) {
    ImGui_RenderCheckMark(draw_list, *pos, col, sz);
}

extern "C" void ImGui_RenderColorComponentMarker_wrap(ImRect const* bb, ImU32 col, float rounding) {
    ImGui_RenderColorComponentMarker(*bb, col, rounding);
}

extern "C" void ImGui_RenderColorRectWithAlphaCheckerboard_wrap(ImDrawList* draw_list, ImVec2 const* p_min, ImVec2 const* p_max, ImU32 col, float alpha, float grid_step, ImVec2 const* grid_off, float rounding, ImDrawFlags flags) {
    ImGui_RenderColorRectWithAlphaCheckerboard(draw_list, *p_min, *p_max, col, alpha, grid_step, *grid_off, rounding, flags);
}

extern "C" void ImGui_RenderDragDropTargetRectEx_wrap(ImDrawList* draw_list, ImRect const* bb, float rounding) {
    ImGui_RenderDragDropTargetRectEx(draw_list, *bb, rounding);
}

extern "C" void ImGui_RenderDragDropTargetRectForItem_wrap(ImRect const* bb) {
    ImGui_RenderDragDropTargetRectForItem(*bb);
}

extern "C" void ImGui_RenderDragDropTargetRectForViewport_wrap(ImGuiID viewport_id, ImRect const* bb) {
    ImGui_RenderDragDropTargetRectForViewport(viewport_id, *bb);
}

extern "C" void ImGui_RenderFrame_wrap(ImVec2 const* p_min, ImVec2 const* p_max, ImU32 fill_col, bool borders, float rounding) {
    ImGui_RenderFrame(*p_min, *p_max, fill_col, borders, rounding);
}

extern "C" void ImGui_RenderFrameBorder_wrap(ImVec2 const* p_min, ImVec2 const* p_max, float rounding) {
    ImGui_RenderFrameBorder(*p_min, *p_max, rounding);
}

extern "C" void ImGui_RenderMouseCursor_wrap(ImVec2 const* pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow) {
    ImGui_RenderMouseCursor(*pos, scale, mouse_cursor, col_fill, col_border, col_shadow);
}

extern "C" void ImGui_RenderNavCursor_wrap(ImRect const* bb, ImGuiID id, ImGuiNavRenderCursorFlags flags, float rounding) {
    ImGui_RenderNavCursor(*bb, id, flags, rounding);
}

extern "C" void ImGui_RenderRectFilledInRangeH_wrap(ImDrawList* draw_list, ImRect const* rect, ImU32 col, float fill_x0, float fill_x1, float rounding) {
    ImGui_RenderRectFilledInRangeH(draw_list, *rect, col, fill_x0, fill_x1, rounding);
}

extern "C" void ImGui_RenderRectFilledWithHole_wrap(ImDrawList* draw_list, ImRect const* outer, ImRect const* inner, ImU32 col, float rounding) {
    ImGui_RenderRectFilledWithHole(draw_list, *outer, *inner, col, rounding);
}

extern "C" void ImGui_RenderText_wrap(ImVec2 const* pos, const char* text, const char* text_end, bool hide_text_after_hash) {
    ImGui_RenderText(*pos, text, text_end, hide_text_after_hash);
}

extern "C" void ImGui_RenderTextClipped_wrap(ImVec2 const* pos_min, ImVec2 const* pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImVec2 const* align, const ImRect* clip_rect) {
    ImGui_RenderTextClipped(*pos_min, *pos_max, text, text_end, text_size_if_known, *align, clip_rect);
}

extern "C" void ImGui_RenderTextClippedWithDrawList_wrap(ImDrawList* draw_list, ImVec2 const* pos_min, ImVec2 const* pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, ImVec2 const* align, const ImRect* clip_rect) {
    ImGui_RenderTextClippedWithDrawList(draw_list, *pos_min, *pos_max, text, text_end, text_size_if_known, *align, clip_rect);
}

extern "C" void ImGui_RenderTextEllipsis_wrap(ImDrawList* draw_list, ImVec2 const* pos_min, ImVec2 const* pos_max, float ellipsis_max_x, const char* text, const char* text_end, const ImVec2* text_size_if_known) {
    ImGui_RenderTextEllipsis(draw_list, *pos_min, *pos_max, ellipsis_max_x, text, text_end, text_size_if_known);
}

extern "C" void ImGui_RenderTextWrapped_wrap(ImVec2 const* pos, const char* text, const char* text_end, float wrap_width) {
    ImGui_RenderTextWrapped(*pos, text, text_end, wrap_width);
}

extern "C" void ImGui_ScrollToBringRectIntoView_wrap(ImGuiWindow* window, ImRect const* rect) {
    ImGui_ScrollToBringRectIntoView(window, *rect);
}

extern "C" void ImGui_ScrollToRect_wrap(ImGuiWindow* window, ImRect const* rect, ImGuiScrollFlags flags) {
    ImGui_ScrollToRect(window, *rect, flags);
}

extern "C" void ImGui_ScrollToRectEx_wrap(ImGuiWindow* window, ImRect const* rect, ImGuiScrollFlags flags, ImVec2* _out) {
    *_out = ImGui_ScrollToRectEx(window, *rect, flags);
}

extern "C" bool ImGui_ScrollbarEx_wrap(ImRect const* bb, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags draw_rounding_flags) {
    return ImGui_ScrollbarEx(*bb, id, axis, p_scroll_v, avail_v, contents_v, draw_rounding_flags);
}

extern "C" void ImGui_SetLastItemData_wrap(ImGuiID item_id, ImGuiItemFlags item_flags, ImGuiItemStatusFlags status_flags, ImRect const* item_rect) {
    ImGui_SetLastItemData(item_id, item_flags, status_flags, *item_rect);
}

extern "C" void ImGui_SetNavID_wrap(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, ImRect const* rect_rel) {
    ImGui_SetNavID(id, nav_layer, focus_scope_id, *rect_rel);
}

extern "C" void ImGui_SetWindowClipRectBeforeSetChannel_wrap(ImGuiWindow* window, ImRect const* clip_rect) {
    ImGui_SetWindowClipRectBeforeSetChannel(window, *clip_rect);
}

extern "C" void ImGui_SetWindowHitTestHole_wrap(ImGuiWindow* window, ImVec2 const* pos, ImVec2 const* size) {
    ImGui_SetWindowHitTestHole(window, *pos, *size);
}

extern "C" void ImGui_SetWindowPosImGuiWindowPtr_wrap(ImGuiWindow* window, ImVec2 const* pos, ImGuiCond cond) {
    ImGui_SetWindowPosImGuiWindowPtr(window, *pos, cond);
}

extern "C" void ImGui_SetWindowSizeImGuiWindowPtr_wrap(ImGuiWindow* window, ImVec2 const* size, ImGuiCond cond) {
    ImGui_SetWindowSizeImGuiWindowPtr(window, *size, cond);
}

extern "C" void ImGui_ShadeVertsLinearColorGradientKeepAlpha_wrap(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 const* gradient_p0, ImVec2 const* gradient_p1, ImU32 col0, ImU32 col1) {
    ImGui_ShadeVertsLinearColorGradientKeepAlpha(draw_list, vert_start_idx, vert_end_idx, *gradient_p0, *gradient_p1, col0, col1);
}

extern "C" void ImGui_ShadeVertsLinearUV_wrap(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 const* a, ImVec2 const* b, ImVec2 const* uv_a, ImVec2 const* uv_b, bool clamp) {
    ImGui_ShadeVertsLinearUV(draw_list, vert_start_idx, vert_end_idx, *a, *b, *uv_a, *uv_b, clamp);
}

extern "C" void ImGui_ShadeVertsTransformPos_wrap(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 const* pivot_in, float cos_a, float sin_a, ImVec2 const* pivot_out) {
    ImGui_ShadeVertsTransformPos(draw_list, vert_start_idx, vert_end_idx, *pivot_in, cos_a, sin_a, *pivot_out);
}

extern "C" bool ImGui_SliderBehavior_wrap(ImRect const* bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb) {
    return ImGui_SliderBehavior(*bb, id, data_type, p_v, p_min, p_max, format, flags, out_grab_bb);
}

extern "C" bool ImGui_SplitterBehavior_wrap(ImRect const* bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend, float hover_visibility_delay, ImU32 bg_col) {
    return ImGui_SplitterBehavior(*bb, id, axis, size1, size2, min_size1, min_size2, hover_extend, hover_visibility_delay, bg_col);
}

extern "C" void ImGui_TabBarGetTabPos_wrap(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, ImVec2* _out) {
    *_out = ImGui_TabBarGetTabPos(tab_bar, tab);
}

extern "C" void ImGui_TabBarQueueReorderFromMousePos_wrap(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, ImVec2 const* mouse_pos) {
    ImGui_TabBarQueueReorderFromMousePos(tab_bar, tab, *mouse_pos);
}

extern "C" void ImGui_TabItemBackground_wrap(ImDrawList* draw_list, ImRect const* bb, ImGuiTabItemFlags flags, ImU32 col) {
    ImGui_TabItemBackground(draw_list, *bb, flags, col);
}

extern "C" void ImGui_TabItemCalcSize_wrap(ImGuiWindow* window, ImVec2* _out) {
    *_out = ImGui_TabItemCalcSize(window);
}

extern "C" void ImGui_TabItemCalcSizeStr_wrap(const char* label, bool has_close_button_or_unsaved_marker, ImVec2* _out) {
    *_out = ImGui_TabItemCalcSizeStr(label, has_close_button_or_unsaved_marker);
}

extern "C" void ImGui_TabItemLabelAndCloseButton_wrap(ImDrawList* draw_list, ImRect const* bb, ImGuiTabItemFlags flags, ImVec2 const* frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped) {
    ImGui_TabItemLabelAndCloseButton(draw_list, *bb, flags, *frame_padding, label, tab_id, close_button_id, is_contents_visible, out_just_closed, out_text_clipped);
}

extern "C" void ImGui_TableGetCellBgRect_wrap(const ImGuiTable* table, int column_n, ImRect* _out) {
    *_out = ImGui_TableGetCellBgRect(table, column_n);
}

extern "C" void ImGui_TeleportMousePos_wrap(ImVec2 const* pos) {
    ImGui_TeleportMousePos(*pos);
}

extern "C" bool ImGui_TempInputScalar_wrap(ImRect const* bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min, const void* p_clamp_max) {
    return ImGui_TempInputScalar(*bb, id, label, data_type, p_data, format, p_clamp_min, p_clamp_max);
}

extern "C" bool ImGui_TempInputText_wrap(ImRect const* bb, ImGuiID id, const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data) {
    return ImGui_TempInputText(*bb, id, label, buf, buf_size, flags, callback, user_data);
}

extern "C" void ImGui_TranslateWindowsInViewport_wrap(ImGuiViewportP* viewport, ImVec2 const* old_pos, ImVec2 const* new_pos, ImVec2 const* old_size, ImVec2 const* new_size) {
    ImGui_TranslateWindowsInViewport(viewport, *old_pos, *new_pos, *old_size, *new_size);
}

extern "C" void ImGui_TreeNodeDrawLineToChildNode_wrap(ImVec2 const* target_pos) {
    ImGui_TreeNodeDrawLineToChildNode(*target_pos);
}

extern "C" void ImGui_UpdateHoveredWindowAndCaptureFlags_wrap(ImVec2 const* mouse_pos) {
    ImGui_UpdateHoveredWindowAndCaptureFlags(*mouse_pos);
}

extern "C" void ImGui_WindowPosAbsToRel_wrap(ImGuiWindow* window, ImVec2 const* p, ImVec2* _out) {
    *_out = ImGui_WindowPosAbsToRel(window, *p);
}

extern "C" void ImGui_WindowPosRelToAbs_wrap(ImGuiWindow* window, ImVec2 const* p, ImVec2* _out) {
    *_out = ImGui_WindowPosRelToAbs(window, *p);
}

extern "C" void ImGui_WindowRectAbsToRel_wrap(ImGuiWindow* window, ImRect const* r, ImRect* _out) {
    *_out = ImGui_WindowRectAbsToRel(window, *r);
}

extern "C" void ImGui_WindowRectRelToAbs_wrap(ImGuiWindow* window, ImRect const* r, ImRect* _out) {
    *_out = ImGui_WindowRectRelToAbs(window, *r);
}

extern "C" void ImGuiDockNode_Rect_wrap(const ImGuiDockNode* self, ImRect* _out) {
    *_out = ImGuiDockNode_Rect(self);
}

extern "C" void ImGuiListClipperRange_FromIndices_wrap(int min, int max, ImGuiListClipperRange* _out) {
    *_out = ImGuiListClipperRange_FromIndices(min, max);
}

extern "C" void ImGuiListClipperRange_FromPositions_wrap(float y1, float y2, int off_min, int off_max, ImGuiListClipperRange* _out) {
    *_out = ImGuiListClipperRange_FromPositions(y1, y2, off_min, off_max);
}

extern "C" void ImGuiViewportP_CalcWorkRectPos_wrap(const ImGuiViewportP* self, ImVec2 const* inset_min, ImVec2* _out) {
    *_out = ImGuiViewportP_CalcWorkRectPos(self, *inset_min);
}

extern "C" void ImGuiViewportP_CalcWorkRectSize_wrap(const ImGuiViewportP* self, ImVec2 const* inset_min, ImVec2 const* inset_max, ImVec2* _out) {
    *_out = ImGuiViewportP_CalcWorkRectSize(self, *inset_min, *inset_max);
}

extern "C" void ImGuiViewportP_GetBuildWorkRect_wrap(const ImGuiViewportP* self, ImRect* _out) {
    *_out = ImGuiViewportP_GetBuildWorkRect(self);
}

extern "C" void ImGuiViewportP_GetMainRect_wrap(const ImGuiViewportP* self, ImRect* _out) {
    *_out = ImGuiViewportP_GetMainRect(self);
}

extern "C" void ImGuiViewportP_GetWorkRect_wrap(const ImGuiViewportP* self, ImRect* _out) {
    *_out = ImGuiViewportP_GetWorkRect(self);
}

extern "C" ImGuiID ImGuiWindow_GetIDFromPos_wrap(ImGuiWindow* self, ImVec2 const* p_abs) {
    return ImGuiWindow_GetIDFromPos(self, *p_abs);
}

extern "C" ImGuiID ImGuiWindow_GetIDFromRectangle_wrap(ImGuiWindow* self, ImRect const* r_abs) {
    return ImGuiWindow_GetIDFromRectangle(self, *r_abs);
}

extern "C" void ImGuiWindow_MenuBarRect_wrap(const ImGuiWindow* self, ImRect* _out) {
    *_out = ImGuiWindow_MenuBarRect(self);
}

extern "C" void ImGuiWindow_Rect_wrap(const ImGuiWindow* self, ImRect* _out) {
    *_out = ImGuiWindow_Rect(self);
}

extern "C" void ImGuiWindow_TitleBarRect_wrap(const ImGuiWindow* self, ImRect* _out) {
    *_out = ImGuiWindow_TitleBarRect(self);
}

extern "C" void ImRect_Add_wrap(ImRect* self, ImVec2 const* p) {
    ImRect_Add(self, *p);
}

extern "C" void ImRect_AddImRect_wrap(ImRect* self, ImRect const* r) {
    ImRect_AddImRect(self, *r);
}

extern "C" void ImRect_ClipWith_wrap(ImRect* self, ImRect const* r) {
    ImRect_ClipWith(self, *r);
}

extern "C" void ImRect_ClipWithFull_wrap(ImRect* self, ImRect const* r) {
    ImRect_ClipWithFull(self, *r);
}

extern "C" bool ImRect_Contains_wrap(const ImRect* self, ImVec2 const* p) {
    return ImRect_Contains(self, *p);
}

extern "C" bool ImRect_ContainsImRect_wrap(const ImRect* self, ImRect const* r) {
    return ImRect_ContainsImRect(self, *r);
}

extern "C" bool ImRect_ContainsWithPad_wrap(const ImRect* self, ImVec2 const* p, ImVec2 const* pad) {
    return ImRect_ContainsWithPad(self, *p, *pad);
}

extern "C" void ImRect_ExpandImVec2_wrap(ImRect* self, ImVec2 const* amount) {
    ImRect_ExpandImVec2(self, *amount);
}

extern "C" void ImRect_GetBL_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetBL(self);
}

extern "C" void ImRect_GetBR_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetBR(self);
}

extern "C" void ImRect_GetCenter_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetCenter(self);
}

extern "C" void ImRect_GetSize_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetSize(self);
}

extern "C" void ImRect_GetTL_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetTL(self);
}

extern "C" void ImRect_GetTR_wrap(const ImRect* self, ImVec2* _out) {
    *_out = ImRect_GetTR(self);
}

extern "C" bool ImRect_Overlaps_wrap(const ImRect* self, ImRect const* r) {
    return ImRect_Overlaps(self, *r);
}

extern "C" void ImRect_ToVec4_wrap(const ImRect* self, ImVec4* _out) {
    *_out = ImRect_ToVec4(self);
}

extern "C" void ImRect_Translate_wrap(ImRect* self, ImVec2 const* d) {
    ImRect_Translate(self, *d);
}