ccc

cimgui.cpp

@@ -10,7 +10,102 @@
 
 
 
-CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void)
+static inline ImColor ConvertToCPP_ImColor(const ImColor_c& src)
+{
+    ImColor dest;
+    dest.Value.x = src.Value.x;
+    dest.Value.y = src.Value.y;
+    dest.Value.z = src.Value.z;
+    dest.Value.w = src.Value.w;
+    return dest;
+}
+static inline ImColor_c ConvertFromCPP_ImColor(const ImColor& src)
+{
+    ImColor_c dest;
+    dest.Value.x = src.Value.x;
+    dest.Value.y = src.Value.y;
+    dest.Value.z = src.Value.z;
+    dest.Value.w = src.Value.w;
+    return dest;
+}
+static inline ImRect ConvertToCPP_ImRect(const ImRect_c& src)
+{
+    ImRect dest;
+    dest.Min.x = src.Min.x;
+    dest.Min.y = src.Min.y;
+    dest.Max.x = src.Max.x;
+    dest.Max.y = src.Max.y;
+    return dest;
+}
+static inline ImRect_c ConvertFromCPP_ImRect(const ImRect& src)
+{
+    ImRect_c dest;
+    dest.Min.x = src.Min.x;
+    dest.Min.y = src.Min.y;
+    dest.Max.x = src.Max.x;
+    dest.Max.y = src.Max.y;
+    return dest;
+}
+static inline ImTextureRef ConvertToCPP_ImTextureRef(const ImTextureRef_c& src)
+{
+    ImTextureRef dest;
+    dest._TexData = src._TexData;
+    dest._TexID = src._TexID;
+    return dest;
+}
+static inline ImTextureRef_c ConvertFromCPP_ImTextureRef(const ImTextureRef& src)
+{
+    ImTextureRef_c dest;
+    dest._TexData = src._TexData;
+    dest._TexID = src._TexID;
+    return dest;
+}
+static inline ImVec2 ConvertToCPP_ImVec2(const ImVec2_c& src)
+{
+    ImVec2 dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    return dest;
+}
+static inline ImVec2_c ConvertFromCPP_ImVec2(const ImVec2& src)
+{
+    ImVec2_c dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    return dest;
+}
+static inline ImVec2i ConvertToCPP_ImVec2i(const ImVec2i_c& src)
+{
+    ImVec2i dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    return dest;
+}
+static inline ImVec2i_c ConvertFromCPP_ImVec2i(const ImVec2i& src)
+{
+    ImVec2i_c dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    return dest;
+}
+static inline ImVec4 ConvertToCPP_ImVec4(const ImVec4_c& src)
+{
+    ImVec4 dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    dest.z = src.z;
+    dest.w = src.w;
+    return dest;
+}
+static inline ImVec4_c ConvertFromCPP_ImVec4(const ImVec4& src)
+{
+    ImVec4_c dest;
+    dest.x = src.x;
+    dest.y = src.y;
+    dest.z = src.z;
+    dest.w = src.w;
+    return dest;
+}CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void)
 {
     return IM_NEW(ImVec2)();
 }
@@ -190,13 +285,13 @@ CIMGUI_API float igGetWindowDpiScale()
 {
     return ImGui::GetWindowDpiScale();
 }
-CIMGUI_API void igGetWindowPos(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetWindowPos()
 {
-    *pOut = ImGui::GetWindowPos();
+    return ConverFromCPP_ImVec2(ImGui::GetWindowPos());
 }
-CIMGUI_API void igGetWindowSize(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetWindowSize()
 {
-    *pOut = ImGui::GetWindowSize();
+    return ConverFromCPP_ImVec2(ImGui::GetWindowSize());
 }
 CIMGUI_API float igGetWindowWidth()
 {
@@ -402,9 +497,9 @@ CIMGUI_API void igPopTextWrapPos()
 {
     return ImGui::PopTextWrapPos();
 }
-CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetFontTexUvWhitePixel()
 {
-    *pOut = ImGui::GetFontTexUvWhitePixel();
+    return ConverFromCPP_ImVec2(ImGui::GetFontTexUvWhitePixel());
 }
 CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx,float alpha_mul)
 {
@@ -422,21 +517,21 @@ CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx)
 {
     return &ImGui::GetStyleColorVec4(idx);
 }
-CIMGUI_API void igGetCursorScreenPos(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetCursorScreenPos()
 {
-    *pOut = ImGui::GetCursorScreenPos();
+    return ConverFromCPP_ImVec2(ImGui::GetCursorScreenPos());
 }
 CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos)
 {
     return ImGui::SetCursorScreenPos(pos);
 }
-CIMGUI_API void igGetContentRegionAvail(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetContentRegionAvail()
 {
-    *pOut = ImGui::GetContentRegionAvail();
+    return ConverFromCPP_ImVec2(ImGui::GetContentRegionAvail());
 }
-CIMGUI_API void igGetCursorPos(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetCursorPos()
 {
-    *pOut = ImGui::GetCursorPos();
+    return ConverFromCPP_ImVec2(ImGui::GetCursorPos());
 }
 CIMGUI_API float igGetCursorPosX()
 {
@@ -458,9 +553,9 @@ CIMGUI_API void igSetCursorPosY(float local_y)
 {
     return ImGui::SetCursorPosY(local_y);
 }
-CIMGUI_API void igGetCursorStartPos(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetCursorStartPos()
 {
-    *pOut = ImGui::GetCursorStartPos();
+    return ConverFromCPP_ImVec2(ImGui::GetCursorStartPos());
 }
 CIMGUI_API void igSeparator()
 {
@@ -1547,17 +1642,17 @@ CIMGUI_API ImGuiID igGetItemID()
 {
     return ImGui::GetItemID();
 }
-CIMGUI_API void igGetItemRectMin(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetItemRectMin()
 {
-    *pOut = ImGui::GetItemRectMin();
+    return ConverFromCPP_ImVec2(ImGui::GetItemRectMin());
 }
-CIMGUI_API void igGetItemRectMax(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetItemRectMax()
 {
-    *pOut = ImGui::GetItemRectMax();
+    return ConverFromCPP_ImVec2(ImGui::GetItemRectMax());
 }
-CIMGUI_API void igGetItemRectSize(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetItemRectSize()
 {
-    *pOut = ImGui::GetItemRectSize();
+    return ConverFromCPP_ImVec2(ImGui::GetItemRectSize());
 }
 CIMGUI_API ImGuiViewport* igGetMainViewport()
 {
@@ -1603,13 +1698,13 @@ CIMGUI_API ImGuiStorage* igGetStateStorage()
 {
     return ImGui::GetStateStorage();
 }
-CIMGUI_API void igCalcTextSize(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
+CIMGUI_API ImVec2_c igCalcTextSize(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width)
 {
-    *pOut = ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width);
+    return ConverFromCPP_ImVec2(ImGui::CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width));
 }
-CIMGUI_API void igColorConvertU32ToFloat4(ImVec4 *pOut,ImU32 in)
+CIMGUI_API ImVec4_c igColorConvertU32ToFloat4(ImU32 in)
 {
-    *pOut = ImGui::ColorConvertU32ToFloat4(in);
+    return ConverFromCPP_ImVec2(ImGui::ColorConvertU32ToFloat4(in));
 }
 CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in)
 {
@@ -1699,21 +1794,21 @@ CIMGUI_API bool igIsAnyMouseDown()
 {
     return ImGui::IsAnyMouseDown();
 }
-CIMGUI_API void igGetMousePos(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetMousePos()
 {
-    *pOut = ImGui::GetMousePos();
+    return ConverFromCPP_ImVec2(ImGui::GetMousePos());
 }
-CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2 *pOut)
+CIMGUI_API ImVec2_c igGetMousePosOnOpeningCurrentPopup()
 {
-    *pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
+    return ConverFromCPP_ImVec2(ImGui::GetMousePosOnOpeningCurrentPopup());
 }
 CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold)
 {
     return ImGui::IsMouseDragging(button,lock_threshold);
 }
-CIMGUI_API void igGetMouseDragDelta(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold)
+CIMGUI_API ImVec2_c igGetMouseDragDelta(ImGuiMouseButton button,float lock_threshold)
 {
-    *pOut = ImGui::GetMouseDragDelta(button,lock_threshold);
+    return ConverFromCPP_ImVec2(ImGui::GetMouseDragDelta(button,lock_threshold));
 }
 CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button)
 {
@@ -2224,9 +2319,9 @@ CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a)
 {
     return self->SetHSV(h,s,v,a);
 }
-CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a)
+CIMGUI_API ImColor_c ImColor_HSV(float h,float s,float v,float a)
 {
-    *pOut = ImColor::HSV(h,s,v,a);
+    return ConverFromCPP_ImVec2(ImColor::HSV(h,s,v,a));
 }
 CIMGUI_API ImGuiSelectionBasicStorage* ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage(void)
 {
@@ -2344,13 +2439,13 @@ CIMGUI_API void ImDrawList_PopTexture(ImDrawList* self)
 {
     return self->PopTexture();
 }
-CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2 *pOut,ImDrawList* self)
+CIMGUI_API ImVec2_c ImDrawList_GetClipRectMin(ImDrawList* self)
 {
-    *pOut = self->GetClipRectMin();
+    return ConverFromCPP_ImVec2(self->GetClipRectMin());
 }
-CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2 *pOut,ImDrawList* self)
+CIMGUI_API ImVec2_c ImDrawList_GetClipRectMax(ImDrawList* self)
 {
-    *pOut = self->GetClipRectMax();
+    return ConverFromCPP_ImVec2(self->GetClipRectMax());
 }
 CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness)
 {
@@ -2656,9 +2751,9 @@ CIMGUI_API int ImTextureData_GetPitch(ImTextureData* self)
 {
     return self->GetPitch();
 }
-CIMGUI_API void ImTextureData_GetTexRef(ImTextureRef *pOut,ImTextureData* self)
+CIMGUI_API ImTextureRef_c ImTextureData_GetTexRef(ImTextureData* self)
 {
-    *pOut = self->GetTexRef();
+    return ConverFromCPP_ImTextureRef(self->GetTexRef());
 }
 CIMGUI_API ImTextureID ImTextureData_GetTexID(ImTextureData* self)
 {
@@ -2860,9 +2955,9 @@ CIMGUI_API ImFontBaked* ImFont_GetFontBaked(ImFont* self,float font_size,float d
 {
     return self->GetFontBaked(font_size,density);
 }
-CIMGUI_API void ImFont_CalcTextSizeA(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** out_remaining)
+CIMGUI_API ImVec2_c ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** out_remaining)
 {
-    *pOut = self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,out_remaining);
+    return ConverFromCPP_ImVec2(self->CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,out_remaining));
 }
 CIMGUI_API const char* ImFont_CalcWordWrapPosition(ImFont* self,float size,const char* text,const char* text_end,float wrap_width)
 {
@@ -2896,13 +2991,13 @@ CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self)
 {
     IM_DELETE(self);
 }
-CIMGUI_API void ImGuiViewport_GetCenter(ImVec2 *pOut,ImGuiViewport* self)
+CIMGUI_API ImVec2_c ImGuiViewport_GetCenter(ImGuiViewport* self)
 {
-    *pOut = self->GetCenter();
+    return ConverFromCPP_ImVec2(self->GetCenter());
 }
-CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2 *pOut,ImGuiViewport* self)
+CIMGUI_API ImVec2_c ImGuiViewport_GetWorkCenter(ImGuiViewport* self)
 {
-    *pOut = self->GetWorkCenter();
+    return ConverFromCPP_ImVec2(self->GetWorkCenter());
 }
 CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void)
 {
@@ -3135,9 +3230,9 @@ CIMGUI_API int igImTextCountLines(const char* in_text,const char* in_text_end)
 {
     return ImTextCountLines(in_text,in_text_end);
 }
-CIMGUI_API void igImFontCalcTextSizeEx(ImVec2 *pOut,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)
+CIMGUI_API ImVec2_c igImFontCalcTextSizeEx(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)
 {
-    *pOut = ImFontCalcTextSizeEx(font,size,max_width,wrap_width,text_begin,text_end_display,text_end,out_remaining,out_offset,flags);
+    return ConverFromCPP_ImVec2(ImFontCalcTextSizeEx(font,size,max_width,wrap_width,text_begin,text_end_display,text_end,out_remaining,out_offset,flags));
 }
 CIMGUI_API const char* igImFontCalcWordWrapPositionEx(ImFont* font,float size,const char* text,const char* text_end,float wrap_width,ImDrawTextFlags flags)
 {
@@ -3215,29 +3310,29 @@ CIMGUI_API double igImRsqrt_double(double x)
 {
     return ImRsqrt(x);
 }
-CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
+CIMGUI_API ImVec2_c igImMin(const ImVec2 lhs,const ImVec2 rhs)
 {
-    *pOut = ImMin(lhs,rhs);
+    return ConverFromCPP_ImVec2(ImMin(lhs,rhs));
 }
-CIMGUI_API void igImMax(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
+CIMGUI_API ImVec2_c igImMax(const ImVec2 lhs,const ImVec2 rhs)
 {
-    *pOut = ImMax(lhs,rhs);
+    return ConverFromCPP_ImVec2(ImMax(lhs,rhs));
 }
-CIMGUI_API void igImClamp(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,const ImVec2 mx)
+CIMGUI_API ImVec2_c igImClamp(const ImVec2 v,const ImVec2 mn,const ImVec2 mx)
 {
-    *pOut = ImClamp(v,mn,mx);
+    return ConverFromCPP_ImVec2(ImClamp(v,mn,mx));
 }
-CIMGUI_API void igImLerp_Vec2Float(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t)
+CIMGUI_API ImVec2_c igImLerp_Vec2Float(const ImVec2 a,const ImVec2 b,float t)
 {
-    *pOut = ImLerp(a,b,t);
+    return ConverFromCPP_ImVec2(ImLerp(a,b,t));
 }
-CIMGUI_API void igImLerp_Vec2Vec2(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t)
+CIMGUI_API ImVec2_c igImLerp_Vec2Vec2(const ImVec2 a,const ImVec2 b,const ImVec2 t)
 {
-    *pOut = ImLerp(a,b,t);
+    return ConverFromCPP_ImVec2(ImLerp(a,b,t));
 }
-CIMGUI_API void igImLerp_Vec4(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t)
+CIMGUI_API ImVec4_c igImLerp_Vec4(const ImVec4 a,const ImVec4 b,float t)
 {
-    *pOut = ImLerp(a,b,t);
+    return ConverFromCPP_ImVec2(ImLerp(a,b,t));
 }
 CIMGUI_API float igImSaturate(float f)
 {
@@ -3259,17 +3354,17 @@ CIMGUI_API float igImTrunc_Float(float f)
 {
     return ImTrunc(f);
 }
-CIMGUI_API void igImTrunc_Vec2(ImVec2 *pOut,const ImVec2 v)
+CIMGUI_API ImVec2_c igImTrunc_Vec2(const ImVec2 v)
 {
-    *pOut = ImTrunc(v);
+    return ConverFromCPP_ImVec2(ImTrunc(v));
 }
 CIMGUI_API float igImFloor_Float(float f)
 {
     return ImFloor(f);
 }
-CIMGUI_API void igImFloor_Vec2(ImVec2 *pOut,const ImVec2 v)
+CIMGUI_API ImVec2_c igImFloor_Vec2(const ImVec2 v)
 {
-    *pOut = ImFloor(v);
+    return ConverFromCPP_ImVec2(ImFloor(v));
 }
 CIMGUI_API float igImTrunc64(float f)
 {
@@ -3287,9 +3382,9 @@ CIMGUI_API float igImDot(const ImVec2 a,const ImVec2 b)
 {
     return ImDot(a,b);
 }
-CIMGUI_API void igImRotate(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a)
+CIMGUI_API ImVec2_c igImRotate(const ImVec2 v,float cos_a,float sin_a)
 {
-    *pOut = ImRotate(v,cos_a,sin_a);
+    return ConverFromCPP_ImVec2(ImRotate(v,cos_a,sin_a));
 }
 CIMGUI_API float igImLinearSweep(float current,float target,float speed)
 {
@@ -3299,9 +3394,9 @@ CIMGUI_API float igImLinearRemapClamp(float s0,float s1,float d0,float d1,float
 {
     return ImLinearRemapClamp(s0,s1,d0,d1,x);
 }
-CIMGUI_API void igImMul(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs)
+CIMGUI_API ImVec2_c igImMul(const ImVec2 lhs,const ImVec2 rhs)
 {
-    *pOut = ImMul(lhs,rhs);
+    return ConverFromCPP_ImVec2(ImMul(lhs,rhs));
 }
 CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f)
 {
@@ -3311,33 +3406,33 @@ CIMGUI_API float igImExponentialMovingAverage(float avg,float sample,int n)
 {
     return ImExponentialMovingAverage(avg,sample,n);
 }
-CIMGUI_API void igImBezierCubicCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t)
+CIMGUI_API ImVec2_c igImBezierCubicCalc(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t)
 {
-    *pOut = ImBezierCubicCalc(p1,p2,p3,p4,t);
+    return ConverFromCPP_ImVec2(ImBezierCubicCalc(p1,p2,p3,p4,t));
 }
-CIMGUI_API void igImBezierCubicClosestPoint(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments)
+CIMGUI_API ImVec2_c igImBezierCubicClosestPoint(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments)
 {
-    *pOut = ImBezierCubicClosestPoint(p1,p2,p3,p4,p,num_segments);
+    return ConverFromCPP_ImVec2(ImBezierCubicClosestPoint(p1,p2,p3,p4,p,num_segments));
 }
-CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol)
+CIMGUI_API ImVec2_c igImBezierCubicClosestPointCasteljau(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol)
 {
-    *pOut = ImBezierCubicClosestPointCasteljau(p1,p2,p3,p4,p,tess_tol);
+    return ConverFromCPP_ImVec2(ImBezierCubicClosestPointCasteljau(p1,p2,p3,p4,p,tess_tol));
 }
-CIMGUI_API void igImBezierQuadraticCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t)
+CIMGUI_API ImVec2_c igImBezierQuadraticCalc(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t)
 {
-    *pOut = ImBezierQuadraticCalc(p1,p2,p3,t);
+    return ConverFromCPP_ImVec2(ImBezierQuadraticCalc(p1,p2,p3,t));
 }
-CIMGUI_API void igImLineClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p)
+CIMGUI_API ImVec2_c igImLineClosestPoint(const ImVec2 a,const ImVec2 b,const ImVec2 p)
 {
-    *pOut = ImLineClosestPoint(a,b,p);
+    return ConverFromCPP_ImVec2(ImLineClosestPoint(a,b,p));
 }
 CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
 {
     return ImTriangleContainsPoint(a,b,c,p);
 }
-CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
+CIMGUI_API ImVec2_c igImTriangleClosestPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p)
 {
-    *pOut = ImTriangleClosestPoint(a,b,c,p);
+    return ConverFromCPP_ImVec2(ImTriangleClosestPoint(a,b,c,p));
 }
 CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w)
 {
@@ -3411,13 +3506,13 @@ CIMGUI_API ImRect* ImRect_ImRect_Float(float x1,float y1,float x2,float y2)
 {
     return IM_NEW(ImRect)(x1,y1,x2,y2);
 }
-CIMGUI_API void ImRect_GetCenter(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetCenter(ImRect* self)
 {
-    *pOut = self->GetCenter();
+    return ConverFromCPP_ImVec2(self->GetCenter());
 }
-CIMGUI_API void ImRect_GetSize(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetSize(ImRect* self)
 {
-    *pOut = self->GetSize();
+    return ConverFromCPP_ImVec2(self->GetSize());
 }
 CIMGUI_API float ImRect_GetWidth(ImRect* self)
 {
@@ -3431,21 +3526,21 @@ CIMGUI_API float ImRect_GetArea(ImRect* self)
 {
     return self->GetArea();
 }
-CIMGUI_API void ImRect_GetTL(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetTL(ImRect* self)
 {
-    *pOut = self->GetTL();
+    return ConverFromCPP_ImVec2(self->GetTL());
 }
-CIMGUI_API void ImRect_GetTR(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetTR(ImRect* self)
 {
-    *pOut = self->GetTR();
+    return ConverFromCPP_ImVec2(self->GetTR());
 }
-CIMGUI_API void ImRect_GetBL(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetBL(ImRect* self)
 {
-    *pOut = self->GetBL();
+    return ConverFromCPP_ImVec2(self->GetBL());
 }
-CIMGUI_API void ImRect_GetBR(ImVec2 *pOut,ImRect* self)
+CIMGUI_API ImVec2_c ImRect_GetBR(ImRect* self)
 {
-    *pOut = self->GetBR();
+    return ConverFromCPP_ImVec2(self->GetBR());
 }
 CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self,const ImVec2 p)
 {
@@ -3507,9 +3602,9 @@ CIMGUI_API bool ImRect_IsInverted(ImRect* self)
 {
     return self->IsInverted();
 }
-CIMGUI_API void ImRect_ToVec4(ImVec4 *pOut,ImRect* self)
+CIMGUI_API ImVec4_c ImRect_ToVec4(ImRect* self)
 {
-    *pOut = self->ToVec4();
+    return ConverFromCPP_ImVec4(self->ToVec4());
 }
 CIMGUI_API const ImVec4* ImRect_AsVec4(ImRect* self)
 {
@@ -3967,9 +4062,9 @@ CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self)
 {
     return self->IsEmpty();
 }
-CIMGUI_API void ImGuiDockNode_Rect(ImRect *pOut,ImGuiDockNode* self)
+CIMGUI_API ImRect_c ImGuiDockNode_Rect(ImGuiDockNode* self)
 {
-    *pOut = self->Rect();
+    return ConverFromCPP_ImRect(self->Rect());
 }
 CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,ImGuiDockNodeFlags flags)
 {
@@ -3999,29 +4094,29 @@ CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self)
 {
     return self->ClearRequestFlags();
 }
-CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min)
+CIMGUI_API ImVec2_c ImGuiViewportP_CalcWorkRectPos(ImGuiViewportP* self,const ImVec2 inset_min)
 {
-    *pOut = self->CalcWorkRectPos(inset_min);
+    return ConverFromCPP_ImVec2(self->CalcWorkRectPos(inset_min));
 }
-CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min,const ImVec2 inset_max)
+CIMGUI_API ImVec2_c ImGuiViewportP_CalcWorkRectSize(ImGuiViewportP* self,const ImVec2 inset_min,const ImVec2 inset_max)
 {
-    *pOut = self->CalcWorkRectSize(inset_min,inset_max);
+    return ConverFromCPP_ImVec2(self->CalcWorkRectSize(inset_min,inset_max));
 }
 CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self)
 {
     return self->UpdateWorkRect();
 }
-CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect *pOut,ImGuiViewportP* self)
+CIMGUI_API ImRect_c ImGuiViewportP_GetMainRect(ImGuiViewportP* self)
 {
-    *pOut = self->GetMainRect();
+    return ConverFromCPP_ImRect(self->GetMainRect());
 }
-CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect *pOut,ImGuiViewportP* self)
+CIMGUI_API ImRect_c ImGuiViewportP_GetWorkRect(ImGuiViewportP* self)
 {
-    *pOut = self->GetWorkRect();
+    return ConverFromCPP_ImRect(self->GetWorkRect());
 }
-CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect *pOut,ImGuiViewportP* self)
+CIMGUI_API ImRect_c ImGuiViewportP_GetBuildWorkRect(ImGuiViewportP* self)
 {
-    *pOut = self->GetBuildWorkRect();
+    return ConverFromCPP_ImRect(self->GetBuildWorkRect());
 }
 CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void)
 {
@@ -4111,17 +4206,17 @@ CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,const ImRect
 {
     return self->GetIDFromRectangle(r_abs);
 }
-CIMGUI_API void ImGuiWindow_Rect(ImRect *pOut,ImGuiWindow* self)
+CIMGUI_API ImRect_c ImGuiWindow_Rect(ImGuiWindow* self)
 {
-    *pOut = self->Rect();
+    return ConverFromCPP_ImRect(self->Rect());
 }
-CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect *pOut,ImGuiWindow* self)
+CIMGUI_API ImRect_c ImGuiWindow_TitleBarRect(ImGuiWindow* self)
 {
-    *pOut = self->TitleBarRect();
+    return ConverFromCPP_ImRect(self->TitleBarRect());
 }
-CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect *pOut,ImGuiWindow* self)
+CIMGUI_API ImRect_c ImGuiWindow_MenuBarRect(ImGuiWindow* self)
 {
-    *pOut = self->MenuBarRect();
+    return ConverFromCPP_ImRect(self->MenuBarRect());
 }
 CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void)
 {
@@ -4223,9 +4318,9 @@ CIMGUI_API void igUpdateWindowSkipRefresh(ImGuiWindow* window)
 {
     return ImGui::UpdateWindowSkipRefresh(window);
 }
-CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2 *pOut,ImGuiWindow* window)
+CIMGUI_API ImVec2_c igCalcWindowNextAutoFitSize(ImGuiWindow* window)
 {
-    *pOut = ImGui::CalcWindowNextAutoFitSize(window);
+    return ConverFromCPP_ImVec2(ImGui::CalcWindowNextAutoFitSize(window));
 }
 CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy)
 {
@@ -4267,21 +4362,21 @@ CIMGUI_API void igSetWindowParentWindowForFocusRoute(ImGuiWindow* window,ImGuiWi
 {
     return ImGui::SetWindowParentWindowForFocusRoute(window,parent_window);
 }
-CIMGUI_API void igWindowRectAbsToRel(ImRect *pOut,ImGuiWindow* window,const ImRect r)
+CIMGUI_API ImRect_c igWindowRectAbsToRel(ImGuiWindow* window,const ImRect r)
 {
-    *pOut = ImGui::WindowRectAbsToRel(window,r);
+    return ConverFromCPP_ImVec2(ImGui::WindowRectAbsToRel(window,r));
 }
-CIMGUI_API void igWindowRectRelToAbs(ImRect *pOut,ImGuiWindow* window,const ImRect r)
+CIMGUI_API ImRect_c igWindowRectRelToAbs(ImGuiWindow* window,const ImRect r)
 {
-    *pOut = ImGui::WindowRectRelToAbs(window,r);
+    return ConverFromCPP_ImVec2(ImGui::WindowRectRelToAbs(window,r));
 }
-CIMGUI_API void igWindowPosAbsToRel(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p)
+CIMGUI_API ImVec2_c igWindowPosAbsToRel(ImGuiWindow* window,const ImVec2 p)
 {
-    *pOut = ImGui::WindowPosAbsToRel(window,p);
+    return ConverFromCPP_ImVec2(ImGui::WindowPosAbsToRel(window,p));
 }
-CIMGUI_API void igWindowPosRelToAbs(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p)
+CIMGUI_API ImVec2_c igWindowPosRelToAbs(ImGuiWindow* window,const ImVec2 p)
 {
-    *pOut = ImGui::WindowPosRelToAbs(window,p);
+    return ConverFromCPP_ImVec2(ImGui::WindowPosRelToAbs(window,p));
 }
 CIMGUI_API void igFocusWindow(ImGuiWindow* window,ImGuiFocusRequestFlags flags)
 {
@@ -4527,9 +4622,9 @@ CIMGUI_API void igScrollToRect(ImGuiWindow* window,const ImRect rect,ImGuiScroll
 {
     return ImGui::ScrollToRect(window,rect,flags);
 }
-CIMGUI_API void igScrollToRectEx(ImVec2 *pOut,ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)
+CIMGUI_API ImVec2_c igScrollToRectEx(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags)
 {
-    *pOut = ImGui::ScrollToRectEx(window,rect,flags);
+    return ConverFromCPP_ImVec2(ImGui::ScrollToRectEx(window,rect,flags));
 }
 CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,const ImRect rect)
 {
@@ -4619,9 +4714,9 @@ CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags item_flags,ImGu
 {
     return ImGui::SetLastItemData(item_id,item_flags,status_flags,item_rect);
 }
-CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h)
+CIMGUI_API ImVec2_c igCalcItemSize(ImVec2 size,float default_w,float default_h)
 {
-    *pOut = ImGui::CalcItemSize(size,default_w,default_h);
+    return ConverFromCPP_ImVec2(ImGui::CalcItemSize(size,default_w,default_h));
 }
 CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos,float wrap_pos_x)
 {
@@ -4699,9 +4794,9 @@ CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::IsPopupOpen(id,popup_flags);
 }
-CIMGUI_API void igGetPopupAllowedExtentRect(ImRect *pOut,ImGuiWindow* window)
+CIMGUI_API ImRect_c igGetPopupAllowedExtentRect(ImGuiWindow* window)
 {
-    *pOut = ImGui::GetPopupAllowedExtentRect(window);
+    return ConverFromCPP_ImVec2(ImGui::GetPopupAllowedExtentRect(window));
 }
 CIMGUI_API ImGuiWindow* igGetTopMostPopupModal()
 {
@@ -4715,13 +4810,13 @@ CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window)
 {
     return ImGui::FindBlockingModal(window);
 }
-CIMGUI_API void igFindBestWindowPosForPopup(ImVec2 *pOut,ImGuiWindow* window)
+CIMGUI_API ImVec2_c igFindBestWindowPosForPopup(ImGuiWindow* window)
 {
-    *pOut = ImGui::FindBestWindowPosForPopup(window);
+    return ConverFromCPP_ImVec2(ImGui::FindBestWindowPosForPopup(window));
 }
-CIMGUI_API void igFindBestWindowPosForPopupEx(ImVec2 *pOut,const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy)
+CIMGUI_API ImVec2_c igFindBestWindowPosForPopupEx(const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy)
 {
-    *pOut = ImGui::FindBestWindowPosForPopupEx(ref_pos,size,last_dir,r_outer,r_avoid,policy);
+    return ConverFromCPP_ImVec2(ImGui::FindBestWindowPosForPopupEx(ref_pos,size,last_dir,r_outer,r_avoid,policy));
 }
 CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags)
 {
@@ -4891,9 +4986,9 @@ CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,float lock_th
 {
     return ImGui::IsMouseDragPastThreshold(button,lock_threshold);
 }
-CIMGUI_API void igGetKeyMagnitude2d(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)
+CIMGUI_API ImVec2_c igGetKeyMagnitude2d(ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down)
 {
-    *pOut = ImGui::GetKeyMagnitude2d(key_left,key_right,key_up,key_down);
+    return ConverFromCPP_ImVec2(ImGui::GetKeyMagnitude2d(key_left,key_right,key_up,key_down));
 }
 CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis)
 {
@@ -5427,9 +5522,9 @@ CIMGUI_API void igTableEndCell(ImGuiTable* table)
 {
     return ImGui::TableEndCell(table);
 }
-CIMGUI_API void igTableGetCellBgRect(ImRect *pOut,const ImGuiTable* table,int column_n)
+CIMGUI_API ImRect_c igTableGetCellBgRect(const ImGuiTable* table,int column_n)
 {
-    *pOut = ImGui::TableGetCellBgRect(table,column_n);
+    return ConverFromCPP_ImVec2(ImGui::TableGetCellBgRect(table,column_n));
 }
 CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n)
 {
@@ -5575,13 +5670,13 @@ CIMGUI_API void igTabItemSpacing(const char* str_id,ImGuiTabItemFlags flags,floa
 {
     return ImGui::TabItemSpacing(str_id,flags,width);
 }
-CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker)
+CIMGUI_API ImVec2_c igTabItemCalcSize_Str(const char* label,bool has_close_button_or_unsaved_marker)
 {
-    *pOut = ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker);
+    return ConverFromCPP_ImVec2(ImGui::TabItemCalcSize(label,has_close_button_or_unsaved_marker));
 }
-CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window)
+CIMGUI_API ImVec2_c igTabItemCalcSize_WindowPtr(ImGuiWindow* window)
 {
-    *pOut = ImGui::TabItemCalcSize(window);
+    return ConverFromCPP_ImVec2(ImGui::TabItemCalcSize(window));
 }
 CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col)
 {
@@ -5732,9 +5827,9 @@ CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p
 {
     return ImGui::ScrollbarEx(bb,id,axis,p_scroll_v,avail_v,contents_v,draw_rounding_flags);
 }
-CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis)
+CIMGUI_API ImRect_c igGetWindowScrollbarRect(ImGuiWindow* window,ImGuiAxis axis)
 {
-    *pOut = ImGui::GetWindowScrollbarRect(window,axis);
+    return ConverFromCPP_ImVec2(ImGui::GetWindowScrollbarRect(window,axis));
 }
 CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window,ImGuiAxis axis)
 {
@@ -6148,9 +6243,9 @@ CIMGUI_API void igImFontAtlasTextureCompact(ImFontAtlas* atlas)
 {
     return ImFontAtlasTextureCompact(atlas);
 }
-CIMGUI_API void igImFontAtlasTextureGetSizeEstimate(ImVec2i *pOut,ImFontAtlas* atlas)
+CIMGUI_API ImVec2i_c igImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas)
 {
-    *pOut = ImFontAtlasTextureGetSizeEstimate(atlas);
+    return ConverFromCPP_ImVec2(ImFontAtlasTextureGetSizeEstimate(atlas));
 }
 CIMGUI_API void igImFontAtlasBuildSetupFontSpecialGlyphs(ImFontAtlas* atlas,ImFont* font,ImFontConfig* src)
 {

cimgui.h

@@ -45,6 +45,45 @@ typedef unsigned __int64 ImU64;
 #endif
 #endif
 
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+typedef struct ImColor_c ImColor;
+typedef struct ImRect_c ImRect;
+typedef struct ImTextureRef_c ImTextureRef;
+typedef struct ImVec2_c ImVec2;
+typedef struct ImVec2i_c ImVec2i;
+typedef struct ImVec4_c ImVec4;
+#endif
+typedef struct ImColor_c ImColor_c;
+struct ImColor_c {
+    ImVec4 Value;
+};
+typedef struct ImRect_c ImRect_c;
+struct ImRect_c {
+    ImVec2 Min;
+    ImVec2 Max;
+};
+typedef struct ImTextureRef_c ImTextureRef_c;
+struct ImTextureRef_c {
+    ImTextureData* _TexData;
+    ImTextureID _TexID;
+};
+typedef struct ImVec2_c ImVec2_c;
+struct ImVec2_c {
+    float x;
+    float y;
+};
+typedef struct ImVec2i_c ImVec2i_c;
+struct ImVec2i_c {
+    int x;
+    int y;
+};
+typedef struct ImVec4_c ImVec4_c;
+struct ImVec4_c {
+    float x;
+    float y;
+    float z;
+    float w;
+};
 
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 
@@ -3937,8 +3976,8 @@ CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags);
 CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags);
 CIMGUI_API ImDrawList* igGetWindowDrawList(void);
 CIMGUI_API float igGetWindowDpiScale(void);
-CIMGUI_API void igGetWindowPos(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetWindowPos(void);
-CIMGUI_API void igGetWindowSize(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetWindowSize(void);
 CIMGUI_API float igGetWindowWidth(void);
 CIMGUI_API float igGetWindowHeight(void);
 CIMGUI_API ImGuiViewport* igGetWindowViewport(void);
@@ -3990,21 +4029,21 @@ CIMGUI_API void igSetNextItemWidth(float item_width);
 CIMGUI_API float igCalcItemWidth(void);
 CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x);
 CIMGUI_API void igPopTextWrapPos(void);
-CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetFontTexUvWhitePixel(void);
 CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx,float alpha_mul);
 CIMGUI_API ImU32 igGetColorU32_Vec4(const ImVec4 col);
 CIMGUI_API ImU32 igGetColorU32_U32(ImU32 col,float alpha_mul);
 CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx);
-CIMGUI_API void igGetCursorScreenPos(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetCursorScreenPos(void);
 CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos);
-CIMGUI_API void igGetContentRegionAvail(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetContentRegionAvail(void);
-CIMGUI_API void igGetCursorPos(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetCursorPos(void);
 CIMGUI_API float igGetCursorPosX(void);
 CIMGUI_API float igGetCursorPosY(void);
 CIMGUI_API void igSetCursorPos(const ImVec2 local_pos);
 CIMGUI_API void igSetCursorPosX(float local_x);
 CIMGUI_API void igSetCursorPosY(float local_y);
-CIMGUI_API void igGetCursorStartPos(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetCursorStartPos(void);
 CIMGUI_API void igSeparator(void);
 CIMGUI_API void igSameLine(float offset_from_start_x,float spacing);
 CIMGUI_API void igNewLine(void);
@@ -4285,9 +4324,9 @@ CIMGUI_API bool igIsAnyItemHovered(void);
 CIMGUI_API bool igIsAnyItemActive(void);
 CIMGUI_API bool igIsAnyItemFocused(void);
 CIMGUI_API ImGuiID igGetItemID(void);
-CIMGUI_API void igGetItemRectMin(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetItemRectMin(void);
-CIMGUI_API void igGetItemRectMax(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetItemRectMax(void);
-CIMGUI_API void igGetItemRectSize(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetItemRectSize(void);
 CIMGUI_API ImGuiViewport* igGetMainViewport(void);
 CIMGUI_API ImDrawList* igGetBackgroundDrawList(ImGuiViewport* viewport);
 CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport);
@@ -4299,8 +4338,8 @@ CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData(void);
 CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx);
 CIMGUI_API void igSetStateStorage(ImGuiStorage* storage);
 CIMGUI_API ImGuiStorage* igGetStateStorage(void);
-CIMGUI_API void igCalcTextSize(ImVec2 *pOut,const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width);
+CIMGUI_API ImVec2_c igCalcTextSize(const char* text,const char* text_end,bool hide_text_after_double_hash,float wrap_width);
-CIMGUI_API void igColorConvertU32ToFloat4(ImVec4 *pOut,ImU32 in);
+CIMGUI_API ImVec4_c igColorConvertU32ToFloat4(ImU32 in);
 CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in);
 CIMGUI_API void igColorConvertRGBtoHSV(float r,float g,float b,float* out_h,float* out_s,float* out_v);
 CIMGUI_API void igColorConvertHSVtoRGB(float h,float s,float v,float* out_r,float* out_g,float* out_b);
@@ -4323,10 +4362,10 @@ CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button);
 CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max,bool clip);
 CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos);
 CIMGUI_API bool igIsAnyMouseDown(void);
-CIMGUI_API void igGetMousePos(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetMousePos(void);
-CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2 *pOut);
+CIMGUI_API ImVec2_c igGetMousePosOnOpeningCurrentPopup(void);
 CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,float lock_threshold);
-CIMGUI_API void igGetMouseDragDelta(ImVec2 *pOut,ImGuiMouseButton button,float lock_threshold);
+CIMGUI_API ImVec2_c igGetMouseDragDelta(ImGuiMouseButton button,float lock_threshold);
 CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button);
 CIMGUI_API ImGuiMouseCursor igGetMouseCursor(void);
 CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type);
@@ -4455,7 +4494,7 @@ CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col);
 CIMGUI_API ImColor* ImColor_ImColor_Int(int r,int g,int b,int a);
 CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba);
 CIMGUI_API void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a);
-CIMGUI_API void ImColor_HSV(ImColor *pOut,float h,float s,float v,float a);
+CIMGUI_API ImColor_c ImColor_HSV(float h,float s,float v,float a);
 CIMGUI_API ImGuiSelectionBasicStorage* ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage(void);
 CIMGUI_API void ImGuiSelectionBasicStorage_destroy(ImGuiSelectionBasicStorage* self);
 CIMGUI_API void ImGuiSelectionBasicStorage_ApplyRequests(ImGuiSelectionBasicStorage* self,ImGuiMultiSelectIO* ms_io);
@@ -4485,8 +4524,8 @@ CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self);
 CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self);
 CIMGUI_API void ImDrawList_PushTexture(ImDrawList* self,ImTextureRef tex_ref);
 CIMGUI_API void ImDrawList_PopTexture(ImDrawList* self);
-CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2 *pOut,ImDrawList* self);
+CIMGUI_API ImVec2_c ImDrawList_GetClipRectMin(ImDrawList* self);
-CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2 *pOut,ImDrawList* self);
+CIMGUI_API ImVec2_c ImDrawList_GetClipRectMax(ImDrawList* self);
 CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,ImU32 col,float thickness);
 CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags,float thickness);
 CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 p_min,const ImVec2 p_max,ImU32 col,float rounding,ImDrawFlags flags);
@@ -4563,7 +4602,7 @@ CIMGUI_API void* ImTextureData_GetPixels(ImTextureData* self);
 CIMGUI_API void* ImTextureData_GetPixelsAt(ImTextureData* self,int x,int y);
 CIMGUI_API int ImTextureData_GetSizeInBytes(ImTextureData* self);
 CIMGUI_API int ImTextureData_GetPitch(ImTextureData* self);
-CIMGUI_API void ImTextureData_GetTexRef(ImTextureRef *pOut,ImTextureData* self);
+CIMGUI_API ImTextureRef_c ImTextureData_GetTexRef(ImTextureData* self);
 CIMGUI_API ImTextureID ImTextureData_GetTexID(ImTextureData* self);
 CIMGUI_API void ImTextureData_SetTexID(ImTextureData* self,ImTextureID tex_id);
 CIMGUI_API void ImTextureData_SetStatus(ImTextureData* self,ImTextureStatus status);
@@ -4614,7 +4653,7 @@ CIMGUI_API bool ImFont_IsGlyphInFont(ImFont* self,ImWchar c);
 CIMGUI_API bool ImFont_IsLoaded(ImFont* self);
 CIMGUI_API const char* ImFont_GetDebugName(ImFont* self);
 CIMGUI_API ImFontBaked* ImFont_GetFontBaked(ImFont* self,float font_size,float density);
-CIMGUI_API void ImFont_CalcTextSizeA(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** out_remaining);
+CIMGUI_API ImVec2_c ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** out_remaining);
 CIMGUI_API const char* ImFont_CalcWordWrapPosition(ImFont* self,float size,const char* text,const char* text_end,float wrap_width);
 CIMGUI_API void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,ImWchar c,const ImVec4* cpu_fine_clip);
 CIMGUI_API void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,const ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width,ImDrawTextFlags flags);
@@ -4623,8 +4662,8 @@ CIMGUI_API void ImFont_AddRemapChar(ImFont* self,ImWchar from_codepoint,ImWchar
 CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,unsigned int c_begin,unsigned int c_last);
 CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void);
 CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self);
-CIMGUI_API void ImGuiViewport_GetCenter(ImVec2 *pOut,ImGuiViewport* self);
+CIMGUI_API ImVec2_c ImGuiViewport_GetCenter(ImGuiViewport* self);
-CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2 *pOut,ImGuiViewport* self);
+CIMGUI_API ImVec2_c ImGuiViewport_GetWorkCenter(ImGuiViewport* self);
 CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void);
 CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self);
 CIMGUI_API void ImGuiPlatformIO_ClearPlatformHandlers(ImGuiPlatformIO* self);
@@ -4684,7 +4723,7 @@ CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,const char* in
 CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,const ImWchar* in_text_end);
 CIMGUI_API const char* igImTextFindPreviousUtf8Codepoint(const char* in_text_start,const char* in_text_curr);
 CIMGUI_API int igImTextCountLines(const char* in_text,const char* in_text_end);
-CIMGUI_API void igImFontCalcTextSizeEx(ImVec2 *pOut,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);
+CIMGUI_API ImVec2_c igImFontCalcTextSizeEx(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);
 CIMGUI_API const char* igImFontCalcWordWrapPositionEx(ImFont* font,float size,const char* text,const char* text_end,float wrap_width,ImDrawTextFlags flags);
 CIMGUI_API const char* igImTextCalcWordWrapNextLineStart(const char* text,const char* text_end,ImDrawTextFlags flags);
 CIMGUI_API ImFileHandle igImFileOpen(const char* filename,const char* mode);
@@ -4704,37 +4743,37 @@ CIMGUI_API float igImSign_Float(float x);
 CIMGUI_API double igImSign_double(double x);
 CIMGUI_API float igImRsqrt_Float(float x);
 CIMGUI_API double igImRsqrt_double(double x);
-CIMGUI_API void igImMin(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs);
+CIMGUI_API ImVec2_c igImMin(const ImVec2 lhs,const ImVec2 rhs);
-CIMGUI_API void igImMax(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs);
+CIMGUI_API ImVec2_c igImMax(const ImVec2 lhs,const ImVec2 rhs);
-CIMGUI_API void igImClamp(ImVec2 *pOut,const ImVec2 v,const ImVec2 mn,const ImVec2 mx);
+CIMGUI_API ImVec2_c igImClamp(const ImVec2 v,const ImVec2 mn,const ImVec2 mx);
-CIMGUI_API void igImLerp_Vec2Float(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,float t);
+CIMGUI_API ImVec2_c igImLerp_Vec2Float(const ImVec2 a,const ImVec2 b,float t);
-CIMGUI_API void igImLerp_Vec2Vec2(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 t);
+CIMGUI_API ImVec2_c igImLerp_Vec2Vec2(const ImVec2 a,const ImVec2 b,const ImVec2 t);
-CIMGUI_API void igImLerp_Vec4(ImVec4 *pOut,const ImVec4 a,const ImVec4 b,float t);
+CIMGUI_API ImVec4_c igImLerp_Vec4(const ImVec4 a,const ImVec4 b,float t);
 CIMGUI_API float igImSaturate(float f);
 CIMGUI_API float igImLengthSqr_Vec2(const ImVec2 lhs);
 CIMGUI_API float igImLengthSqr_Vec4(const ImVec4 lhs);
 CIMGUI_API float igImInvLength(const ImVec2 lhs,float fail_value);
 CIMGUI_API float igImTrunc_Float(float f);
-CIMGUI_API void igImTrunc_Vec2(ImVec2 *pOut,const ImVec2 v);
+CIMGUI_API ImVec2_c igImTrunc_Vec2(const ImVec2 v);
 CIMGUI_API float igImFloor_Float(float f);
-CIMGUI_API void igImFloor_Vec2(ImVec2 *pOut,const ImVec2 v);
+CIMGUI_API ImVec2_c igImFloor_Vec2(const ImVec2 v);
 CIMGUI_API float igImTrunc64(float f);
 CIMGUI_API float igImRound64(float f);
 CIMGUI_API int igImModPositive(int a,int b);
 CIMGUI_API float igImDot(const ImVec2 a,const ImVec2 b);
-CIMGUI_API void igImRotate(ImVec2 *pOut,const ImVec2 v,float cos_a,float sin_a);
+CIMGUI_API ImVec2_c igImRotate(const ImVec2 v,float cos_a,float sin_a);
 CIMGUI_API float igImLinearSweep(float current,float target,float speed);
 CIMGUI_API float igImLinearRemapClamp(float s0,float s1,float d0,float d1,float x);
-CIMGUI_API void igImMul(ImVec2 *pOut,const ImVec2 lhs,const ImVec2 rhs);
+CIMGUI_API ImVec2_c igImMul(const ImVec2 lhs,const ImVec2 rhs);
 CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f);
 CIMGUI_API float igImExponentialMovingAverage(float avg,float sample,int n);
-CIMGUI_API void igImBezierCubicCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t);
+CIMGUI_API ImVec2_c igImBezierCubicCalc(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,float t);
-CIMGUI_API void igImBezierCubicClosestPoint(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments);
+CIMGUI_API ImVec2_c igImBezierCubicClosestPoint(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,int num_segments);
-CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol);
+CIMGUI_API ImVec2_c igImBezierCubicClosestPointCasteljau(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,const ImVec2 p4,const ImVec2 p,float tess_tol);
-CIMGUI_API void igImBezierQuadraticCalc(ImVec2 *pOut,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t);
+CIMGUI_API ImVec2_c igImBezierQuadraticCalc(const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,float t);
-CIMGUI_API void igImLineClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 p);
+CIMGUI_API ImVec2_c igImLineClosestPoint(const ImVec2 a,const ImVec2 b,const ImVec2 p);
 CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p);
-CIMGUI_API void igImTriangleClosestPoint(ImVec2 *pOut,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p);
+CIMGUI_API ImVec2_c igImTriangleClosestPoint(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p);
 CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 p,float* out_u,float* out_v,float* out_w);
 CIMGUI_API float igImTriangleArea(const ImVec2 a,const ImVec2 b,const ImVec2 c);
 CIMGUI_API bool igImTriangleIsClockwise(const ImVec2 a,const ImVec2 b,const ImVec2 c);
@@ -4753,15 +4792,15 @@ CIMGUI_API void ImRect_destroy(ImRect* self);
 CIMGUI_API ImRect* ImRect_ImRect_Vec2(const ImVec2 min,const ImVec2 max);
 CIMGUI_API ImRect* ImRect_ImRect_Vec4(const ImVec4 v);
 CIMGUI_API ImRect* ImRect_ImRect_Float(float x1,float y1,float x2,float y2);
-CIMGUI_API void ImRect_GetCenter(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetCenter(ImRect* self);
-CIMGUI_API void ImRect_GetSize(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetSize(ImRect* self);
 CIMGUI_API float ImRect_GetWidth(ImRect* self);
 CIMGUI_API float ImRect_GetHeight(ImRect* self);
 CIMGUI_API float ImRect_GetArea(ImRect* self);
-CIMGUI_API void ImRect_GetTL(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetTL(ImRect* self);
-CIMGUI_API void ImRect_GetTR(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetTR(ImRect* self);
-CIMGUI_API void ImRect_GetBL(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetBL(ImRect* self);
-CIMGUI_API void ImRect_GetBR(ImVec2 *pOut,ImRect* self);
+CIMGUI_API ImVec2_c ImRect_GetBR(ImRect* self);
 CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self,const ImVec2 p);
 CIMGUI_API bool ImRect_Contains_Rect(ImRect* self,const ImRect r);
 CIMGUI_API bool ImRect_ContainsWithPad(ImRect* self,const ImVec2 p,const ImVec2 pad);
@@ -4777,7 +4816,7 @@ CIMGUI_API void ImRect_ClipWith(ImRect* self,const ImRect r);
 CIMGUI_API void ImRect_ClipWithFull(ImRect* self,const ImRect r);
 CIMGUI_API void ImRect_Floor(ImRect* self);
 CIMGUI_API bool ImRect_IsInverted(ImRect* self);
-CIMGUI_API void ImRect_ToVec4(ImVec4 *pOut,ImRect* self);
+CIMGUI_API ImVec4_c ImRect_ToVec4(ImRect* self);
 CIMGUI_API const ImVec4* ImRect_AsVec4(ImRect* self);
 CIMGUI_API size_t igImBitArrayGetStorageSizeInBytes(int bitcount);
 CIMGUI_API void igImBitArrayClearAllBits(ImU32* arr,int bitcount);
@@ -4892,7 +4931,7 @@ CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self);
 CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self);
 CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self);
 CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self);
-CIMGUI_API void ImGuiDockNode_Rect(ImRect *pOut,ImGuiDockNode* self);
+CIMGUI_API ImRect_c ImGuiDockNode_Rect(ImGuiDockNode* self);
 CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,ImGuiDockNodeFlags flags);
 CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self);
 CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void);
@@ -4900,12 +4939,12 @@ CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self);
 CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void);
 CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self);
 CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self);
-CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min);
+CIMGUI_API ImVec2_c ImGuiViewportP_CalcWorkRectPos(ImGuiViewportP* self,const ImVec2 inset_min);
-CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2 *pOut,ImGuiViewportP* self,const ImVec2 inset_min,const ImVec2 inset_max);
+CIMGUI_API ImVec2_c ImGuiViewportP_CalcWorkRectSize(ImGuiViewportP* self,const ImVec2 inset_min,const ImVec2 inset_max);
 CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self);
-CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect *pOut,ImGuiViewportP* self);
+CIMGUI_API ImRect_c ImGuiViewportP_GetMainRect(ImGuiViewportP* self);
-CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect *pOut,ImGuiViewportP* self);
+CIMGUI_API ImRect_c ImGuiViewportP_GetWorkRect(ImGuiViewportP* self);
-CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect *pOut,ImGuiViewportP* self);
+CIMGUI_API ImRect_c ImGuiViewportP_GetBuildWorkRect(ImGuiViewportP* self);
 CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void);
 CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self);
 CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self);
@@ -4928,9 +4967,9 @@ CIMGUI_API ImGuiID ImGuiWindow_GetID_Ptr(ImGuiWindow* self,const void* ptr);
 CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self,int n);
 CIMGUI_API ImGuiID ImGuiWindow_GetIDFromPos(ImGuiWindow* self,const ImVec2 p_abs);
 CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,const ImRect r_abs);
-CIMGUI_API void ImGuiWindow_Rect(ImRect *pOut,ImGuiWindow* self);
+CIMGUI_API ImRect_c ImGuiWindow_Rect(ImGuiWindow* self);
-CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect *pOut,ImGuiWindow* self);
+CIMGUI_API ImRect_c ImGuiWindow_TitleBarRect(ImGuiWindow* self);
-CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect *pOut,ImGuiWindow* self);
+CIMGUI_API ImRect_c ImGuiWindow_MenuBarRect(ImGuiWindow* self);
 CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void);
 CIMGUI_API void ImGuiTabItem_destroy(ImGuiTabItem* self);
 CIMGUI_API ImGuiTabBar* ImGuiTabBar_ImGuiTabBar(void);
@@ -4956,7 +4995,7 @@ CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id);
 CIMGUI_API ImGuiWindow* igFindWindowByName(const char* name);
 CIMGUI_API void igUpdateWindowParentAndRootLinks(ImGuiWindow* window,ImGuiWindowFlags flags,ImGuiWindow* parent_window);
 CIMGUI_API void igUpdateWindowSkipRefresh(ImGuiWindow* window);
-CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2 *pOut,ImGuiWindow* window);
+CIMGUI_API ImVec2_c igCalcWindowNextAutoFitSize(ImGuiWindow* window);
 CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,ImGuiWindow* potential_parent,bool popup_hierarchy,bool dock_hierarchy);
 CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,ImGuiWindow* potential_parent);
 CIMGUI_API bool igIsWindowAbove(ImGuiWindow* potential_above,ImGuiWindow* potential_below);
@@ -4967,10 +5006,10 @@ CIMGUI_API void igSetWindowCollapsed_WindowPtr(ImGuiWindow* window,bool collapse
 CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,const ImVec2 pos,const ImVec2 size);
 CIMGUI_API void igSetWindowHiddenAndSkipItemsForCurrentFrame(ImGuiWindow* window);
 CIMGUI_API void igSetWindowParentWindowForFocusRoute(ImGuiWindow* window,ImGuiWindow* parent_window);
-CIMGUI_API void igWindowRectAbsToRel(ImRect *pOut,ImGuiWindow* window,const ImRect r);
+CIMGUI_API ImRect_c igWindowRectAbsToRel(ImGuiWindow* window,const ImRect r);
-CIMGUI_API void igWindowRectRelToAbs(ImRect *pOut,ImGuiWindow* window,const ImRect r);
+CIMGUI_API ImRect_c igWindowRectRelToAbs(ImGuiWindow* window,const ImRect r);
-CIMGUI_API void igWindowPosAbsToRel(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p);
+CIMGUI_API ImVec2_c igWindowPosAbsToRel(ImGuiWindow* window,const ImVec2 p);
-CIMGUI_API void igWindowPosRelToAbs(ImVec2 *pOut,ImGuiWindow* window,const ImVec2 p);
+CIMGUI_API ImVec2_c igWindowPosRelToAbs(ImGuiWindow* window,const ImVec2 p);
 CIMGUI_API void igFocusWindow(ImGuiWindow* window,ImGuiFocusRequestFlags flags);
 CIMGUI_API void igFocusTopMostWindowUnderOne(ImGuiWindow* under_this_window,ImGuiWindow* ignore_window,ImGuiViewport* filter_viewport,ImGuiFocusRequestFlags flags);
 CIMGUI_API void igBringWindowToFocusFront(ImGuiWindow* window);
@@ -5032,7 +5071,7 @@ CIMGUI_API void igSetScrollFromPosX_WindowPtr(ImGuiWindow* window,float local_x,
 CIMGUI_API void igSetScrollFromPosY_WindowPtr(ImGuiWindow* window,float local_y,float center_y_ratio);
 CIMGUI_API void igScrollToItem(ImGuiScrollFlags flags);
 CIMGUI_API void igScrollToRect(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags);
-CIMGUI_API void igScrollToRectEx(ImVec2 *pOut,ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags);
+CIMGUI_API ImVec2_c igScrollToRectEx(ImGuiWindow* window,const ImRect rect,ImGuiScrollFlags flags);
 CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,const ImRect rect);
 CIMGUI_API ImGuiItemStatusFlags igGetItemStatusFlags(void);
 CIMGUI_API ImGuiItemFlags igGetItemFlags(void);
@@ -5055,7 +5094,7 @@ CIMGUI_API bool igItemHoverable(const ImRect bb,ImGuiID id,ImGuiItemFlags item_f
 CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,ImGuiHoveredFlags flags);
 CIMGUI_API bool igIsClippedEx(const ImRect bb,ImGuiID id);
 CIMGUI_API void igSetLastItemData(ImGuiID item_id,ImGuiItemFlags item_flags,ImGuiItemStatusFlags status_flags,const ImRect item_rect);
-CIMGUI_API void igCalcItemSize(ImVec2 *pOut,ImVec2 size,float default_w,float default_h);
+CIMGUI_API ImVec2_c igCalcItemSize(ImVec2 size,float default_w,float default_h);
 CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos,float wrap_pos_x);
 CIMGUI_API void igPushMultiItemsWidths(int components,float width_full);
 CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,int count,float width_excess,float width_min);
@@ -5075,12 +5114,12 @@ CIMGUI_API void igClosePopupToLevel(int remaining,bool restore_focus_to_window_u
 CIMGUI_API void igClosePopupsOverWindow(ImGuiWindow* ref_window,bool restore_focus_to_window_under_popup);
 CIMGUI_API void igClosePopupsExceptModals(void);
 CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id,ImGuiPopupFlags popup_flags);
-CIMGUI_API void igGetPopupAllowedExtentRect(ImRect *pOut,ImGuiWindow* window);
+CIMGUI_API ImRect_c igGetPopupAllowedExtentRect(ImGuiWindow* window);
 CIMGUI_API ImGuiWindow* igGetTopMostPopupModal(void);
 CIMGUI_API ImGuiWindow* igGetTopMostAndVisiblePopupModal(void);
 CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window);
-CIMGUI_API void igFindBestWindowPosForPopup(ImVec2 *pOut,ImGuiWindow* window);
+CIMGUI_API ImVec2_c igFindBestWindowPosForPopup(ImGuiWindow* window);
-CIMGUI_API void igFindBestWindowPosForPopupEx(ImVec2 *pOut,const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy);
+CIMGUI_API ImVec2_c igFindBestWindowPosForPopupEx(const ImVec2 ref_pos,const ImVec2 size,ImGuiDir* last_dir,const ImRect r_outer,const ImRect r_avoid,ImGuiPopupPositionPolicy policy);
 CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags);
 CIMGUI_API bool igBeginTooltipHidden(void);
 CIMGUI_API bool igBeginViewportSideBar(const char* name,ImGuiViewport* viewport,ImGuiDir dir,float size,ImGuiWindowFlags window_flags);
@@ -5123,7 +5162,7 @@ CIMGUI_API ImGuiKeyData* igGetKeyData_Key(ImGuiKey key);
 CIMGUI_API const char* igGetKeyChordName(ImGuiKeyChord key_chord);
 CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button);
 CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,float lock_threshold);
-CIMGUI_API void igGetKeyMagnitude2d(ImVec2 *pOut,ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down);
+CIMGUI_API ImVec2_c igGetKeyMagnitude2d(ImGuiKey key_left,ImGuiKey key_right,ImGuiKey key_up,ImGuiKey key_down);
 CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis);
 CIMGUI_API int igCalcTypematicRepeatAmount(float t0,float t1,float repeat_delay,float repeat_rate);
 CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,float* repeat_delay,float* repeat_rate);
@@ -5257,7 +5296,7 @@ CIMGUI_API void igTableBeginRow(ImGuiTable* table);
 CIMGUI_API void igTableEndRow(ImGuiTable* table);
 CIMGUI_API void igTableBeginCell(ImGuiTable* table,int column_n);
 CIMGUI_API void igTableEndCell(ImGuiTable* table);
-CIMGUI_API void igTableGetCellBgRect(ImRect *pOut,const ImGuiTable* table,int column_n);
+CIMGUI_API ImRect_c igTableGetCellBgRect(const ImGuiTable* table,int column_n);
 CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n);
 CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,int column_n,int instance_no);
 CIMGUI_API float igTableCalcMaxColumnWidth(const ImGuiTable* table,int column_n);
@@ -5294,8 +5333,8 @@ CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,ImGuiTabIt
 CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar);
 CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,const char* label,bool* p_open,ImGuiTabItemFlags flags,ImGuiWindow* docked_window);
 CIMGUI_API void igTabItemSpacing(const char* str_id,ImGuiTabItemFlags flags,float width);
-CIMGUI_API void igTabItemCalcSize_Str(ImVec2 *pOut,const char* label,bool has_close_button_or_unsaved_marker);
+CIMGUI_API ImVec2_c igTabItemCalcSize_Str(const char* label,bool has_close_button_or_unsaved_marker);
-CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2 *pOut,ImGuiWindow* window);
+CIMGUI_API ImVec2_c igTabItemCalcSize_WindowPtr(ImGuiWindow* window);
 CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImU32 col);
 CIMGUI_API void igTabItemLabelAndCloseButton(ImDrawList* draw_list,const ImRect bb,ImGuiTabItemFlags flags,ImVec2 frame_padding,const char* label,ImGuiID tab_id,ImGuiID close_button_id,bool is_contents_visible,bool* out_just_closed,bool* out_text_clipped);
 CIMGUI_API void igRenderText(ImVec2 pos,const char* text,const char* text_end,bool hide_text_after_hash);
@@ -5334,7 +5373,7 @@ CIMGUI_API bool igCloseButton(ImGuiID id,const ImVec2 pos);
 CIMGUI_API bool igCollapseButton(ImGuiID id,const ImVec2 pos,ImGuiDockNode* dock_node);
 CIMGUI_API void igScrollbar(ImGuiAxis axis);
 CIMGUI_API bool igScrollbarEx(const ImRect bb,ImGuiID id,ImGuiAxis axis,ImS64* p_scroll_v,ImS64 avail_v,ImS64 contents_v,ImDrawFlags draw_rounding_flags);
-CIMGUI_API void igGetWindowScrollbarRect(ImRect *pOut,ImGuiWindow* window,ImGuiAxis axis);
+CIMGUI_API ImRect_c igGetWindowScrollbarRect(ImGuiWindow* window,ImGuiAxis axis);
 CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window,ImGuiAxis axis);
 CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window,int n);
 CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,ImGuiDir dir);
@@ -5438,7 +5477,7 @@ CIMGUI_API void igImFontAtlasTextureMakeSpace(ImFontAtlas* atlas);
 CIMGUI_API void igImFontAtlasTextureRepack(ImFontAtlas* atlas,int w,int h);
 CIMGUI_API void igImFontAtlasTextureGrow(ImFontAtlas* atlas,int old_w,int old_h);
 CIMGUI_API void igImFontAtlasTextureCompact(ImFontAtlas* atlas);
-CIMGUI_API void igImFontAtlasTextureGetSizeEstimate(ImVec2i *pOut,ImFontAtlas* atlas);
+CIMGUI_API ImVec2i_c igImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas);
 CIMGUI_API void igImFontAtlasBuildSetupFontSpecialGlyphs(ImFontAtlas* atlas,ImFont* font,ImFontConfig* src);
 CIMGUI_API void igImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas);
 CIMGUI_API void igImFontAtlasBuildGetOversampleFactors(ImFontConfig* src,ImFontBaked* baked,int* out_oversample_h,int* out_oversample_v);

cimgui_impl.h

@@ -8,44 +8,44 @@ typedef struct GLFWmonitor GLFWmonitor;
 struct GLFWwindow;
 struct GLFWmonitor;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
-CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
-CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
-CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
-CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
 CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
 CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
-CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
-CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
-CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
-CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
 CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
+CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
 
 #endif
 #ifdef CIMGUI_USE_OPENGL3
-CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
-CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
-CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
 CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
+CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
 
 #endif
 #ifdef CIMGUI_USE_OPENGL2
-CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
-CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
 CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
 
 #endif
@@ -61,18 +61,18 @@ struct _SDL_GameController;
 typedef union SDL_Event SDL_Event;
 typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
-CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
-CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
 CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
 
 #endif
 #ifdef CIMGUI_USE_SDL3
@@ -87,17 +87,17 @@ struct SDL_Gamepad;
 typedef union SDL_Event SDL_Event;
 typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
 CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
+CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
 
 #endif
 #ifdef CIMGUI_USE_VULKAN
@@ -189,25 +189,25 @@ struct ImGui_ImplVulkanH_Window
 typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
 typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
-CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
-CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
-CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
-CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
-CIMGUI_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* info);
-CIMGUI_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);
-CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
-CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
-CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
 CIMGUI_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count,VkImageUsageFlags image_usage);
 CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator);
-CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
-CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
-CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
-CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
 CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
 CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_GetWindowDataFromViewport(ImGuiViewport* viewport);
+CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
+CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
+CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
+CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
 CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);
+CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
+CIMGUI_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* info);
+CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
+CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
+CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
+CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
+CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
+CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
+CIMGUI_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);
 
 #endif
 #endif //CIMGUI_IMPL_DEFINED

generator/cimgui_template.h

@@ -40,6 +40,7 @@ typedef unsigned __int64 ImU64;
 #endif
 #endif
 
+PLACE_STRUCTS_C
 
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "imgui_structs.h"

generator/cpp2ffi.lua

@@ -1,5 +1,5 @@
 local M = {}
-
+local insert = table.insert
 local function ToStr(t,dometatables)
 	local function basicToStr (o)
 		if type(o) == "number" or type(o)=="boolean" then
@@ -936,7 +936,7 @@ local function itemsCount(items)
 		print(v,its and #its or 0)
 	end
 end
-
+--adding self argument for struct functions
 local function AdjustArguments(FP)
     for fun,defs in pairs(FP.defsT) do
         --struct function but no constructors or static functions or manuals
@@ -1083,6 +1083,7 @@ local function DefsByStruct(FP)
     end
     return structs
 end  
+M.DefsByStruct = DefsByStruct
 local function get_nonPOD(FP)
 	local defbystruct = DefsByStruct(FP)
 	--M.prtable(defbystruct)
@@ -1102,8 +1103,139 @@ local function get_nonPOD(FP)
 	FP.structs_and_enums_table.nonPOD = nonPOD
 	return nonPOD
 end
+M.get_nonPOD = get_nonPOD
+local function gen_structs_c(FP)
+	local structs = FP.structs_and_enums_table.structs
+	local tabs = {}
+	local tabs_c = {}
+	--for k,v in pairs(FP.nP_used) do
+	M.table_do_sorted(FP.nP_used, function(k,v)
+		insert(tabs,"typedef struct "..k.."_c "..k.."_c;")
+		insert(tabs_c,"typedef struct "..k.."_c "..k..";")
+		insert(tabs,"struct "..k.."_c {")
+		local struct = structs[k]
+		for i,field in ipairs(struct) do
+			insert(tabs,"    "..field.type.." "..field.name..";")
+		end
+		insert(tabs,"};")
+	end)
+	if #tabs_c > 0 then
+		insert(tabs_c,1,"#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS")
+		insert(tabs_c,"#endif")
+	end
+	--print(table.concat(tabs_c,"\n"))
+	--print(table.concat(tabs,"\n"))
+	return table.concat(tabs_c,"\n").."\n"..table.concat(tabs,"\n")
+end
+local function gen_field_conversion(tab, struct, FP, prefix)
+	prefix = prefix or ""
+	local structs = FP.structs_and_enums_table.structs
+	for i,field in ipairs(struct) do
+		if FP.nP_used[field.type] then
+			gen_field_conversion(tab, structs[field.type],FP, prefix..field.name..".")
+		else
+			insert(tab,"    dest."..prefix..field.name.." = src."..prefix..field.name..";")
+		end
+	end
+end
+local function genConversions(FP)
+	local structs = FP.structs_and_enums_table.structs
+	local convers = {}
+	--for k,v in pairs(FP.nP_used) do
+	M.table_do_sorted(FP.nP_used, function(k,v)
+		insert(convers,"static inline "..k.." ConvertToCPP_"..k.."(const "..k.."_c& src)")
+		insert(convers,"{")
+		insert(convers,"    "..k.." dest;")
+		local struct = structs[k]
+		gen_field_conversion(convers,struct,FP)
+		insert(convers,"    return dest;")
+		insert(convers,"}")
+		insert(convers,"static inline "..k.."_c ConvertFromCPP_"..k.."(const "..k.."& src)")
+		insert(convers,"{")
+		insert(convers,"    "..k.."_c dest;")
+		local struct = structs[k]
+		gen_field_conversion(convers,struct,FP)
+		insert(convers,"    return dest;")
+		insert(convers,"}")
+	end)
+	--print(table.concat(convers,"\n"))
+	return table.concat(convers,"\n")
+end
+local function get_nonPODused(FP)
+	print("get_nonPODused-----------------------------")
+	local nonPOD = FP.structs_and_enums_table.nonPOD
+	--M.prtable(nonPOD)
+	local typeargs = {}
+	local typeargs_ret = {}
+	for k,defs in pairs(FP.defsT) do 
+		--print(k)
+		for i, w in ipairs(defs) do
+			if not w.templated then --and not w.location:match"internal" then
+			for ii,arg in ipairs(w.argsT) do
+				local typ = (arg.type):gsub("&","")
+				--typ = (typ):gsub("*","")
+				typ = (typ):gsub("const ","")
+				if nonPOD[typ] then
+					--print(arg.type,w.ov_cimguiname,w.location)
+					typeargs[arg.type] = (arg.type):gsub(typ,typ.."_c")
+				end
+			end
+			local typret = (w.ret or ""):gsub("&","")
+			--typret = (typret):gsub("*","")
+			typret = (typret):gsub("const ","")
+			--print(typret)
+			if nonPOD[typret] then
+				--print(w.ret,w.ov_cimguiname,w.location)
+				typeargs_ret[w.ret] = (w.ret):gsub(typret,typret.."_c")
+			end
+			end
+		end
+	end
+	local all_type_nP = {}
+	for k,v in pairs(typeargs) do 
+		local k2 = k:gsub("const ","")
+		all_type_nP[k2] = true
+	end
+	for k,v in pairs(typeargs_ret) do 
+		local k2 = k:gsub("const ","")
+		all_type_nP[k2] = true
+	end
+	FP.nP_used = all_type_nP
+	FP.nP_args = typeargs
+	FP.nP_ret = typeargs_ret
+	--genConversions(FP)
+	--M.prtable(typeargs,typeargs_ret,all_type_nP)
+	-- local typeargs2 = {}
+	-- for k,v in pairs(typeargs) do table.insert(typeargs2,k) end
+	-- table.sort(typeargs2)
+	-- print"------------typeargs2----------------"
+	-- M.prtable(typeargs2)
+	
+	-- local typeargs2_ret = {}
+	-- for k,v in pairs(typeargs_ret) do table.insert(typeargs2_ret,k) end
+	-- table.sort(typeargs2_ret)
+	-- print"------------typeargs2_ret----------------"
+	-- M.prtable(typeargs2_ret)
+
+end
 local function ADDnonUDT(FP)
 	local nonPOD = get_nonPOD(FP)
+	get_nonPODused(FP)
+	for k,defs in pairs(FP.defsT) do
+		for i, def in ipairs(defs) do 
+			--ret
+			--local typret = (def.ret):gsub("const ","")
+			if FP.nP_ret[def.ret] then
+				def.conv = (def.ret):gsub("const ","")
+				def.ret = FP.nP_ret[def.ret]
+				def.nonUDT = 1
+			end
+		end
+	end
+end
+local function ADDnonUDT_OLD(FP)
+	local nonPOD = get_nonPOD(FP)
+	get_nonPODused(FP)
 	--print"nonPOD"
 	--M.prtable(nonPOD)
     local defsT = FP.defsT
@@ -1125,6 +1257,7 @@ local function ADDnonUDT(FP)
 		if (not isUDT) and FP.cimgui_inherited and FP.cimgui_inherited.nonPOD[defT.ret] then
 			isUDT = true
 		end
+		--given in generator.lua , could be skipped
 		for _,udt_ret in ipairs(FP.UDTs) do
 			if udt_ret == defT.ret then isUDT=true; break end
 		end
@@ -1289,6 +1422,8 @@ function M.Parser()
 	par.skipped = {}
 	par.UDTs = {}
 	
+	par.genConversors = genConversions
+	par.gen_structs_c = gen_structs_c
 	function par:insert(line,loca)
 		--table.insert(cdefs,{line,loca})
 		--table.insert(cdefs,{line:gsub("^%s*(.-)%s*$", "%1"),loca})
@@ -1343,8 +1478,9 @@ function M.Parser()
 	function par:do_parse()
 		self:parseItems()
 		self:gen_structs_and_enums_table()
-		self:gen_structs_and_enums()
 		self:compute_overloads()
+		self:gen_structs_and_enums()
+		--self:compute_overloads()
 		--self:compute_templated()
 		ADDdestructors(self)
 	end
@@ -1714,6 +1850,30 @@ function M.Parser()
 	function par:header_text_insert(tab,txt,it)
 		table.insert(tab, txt)
 	end
+	local function function_parse(self,it)
+		local stname = ""
+		local namespace
+		if it.parent then
+			if it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" or it.parent.re_name == "class_re" then
+				stname = it.parent.name
+			elseif it.parent.re_name == "namespace_re" then
+				namespace = get_parents_nameC(it) --it.parent.name
+			end
+		end
+		if it.item:match"^%s*template%s+<" then
+			local ttype,fun = it.item:match"^%s*template%s+<%s*typename%s+([^>]+)%s*>%s*(.+)$"
+			if self.ftemplate_list and self.ftemplate_list[ttype] then
+				for iT,vT in ipairs(self.ftemplate_list[ttype]) do
+					local funT = fun:gsub("([< %(])"..ttype,"%1"..vT)
+					--funT = funT:gsub("sizeof%("..ttype.."%)","sizeof("..vT..")")
+					--local funT = fun:gsub(ttype,vT)
+					self:parseFunction(stname,{item=funT},namespace,it.locat)
+				end
+			end
+		else
+			self:parseFunction(stname,it,namespace,it.locat)
+		end
+	end
 	function par:gen_structs_and_enums()
 		print"--------------gen_structs_and_enums"
 		--M.prtable(self.typenames)
@@ -1851,28 +2011,7 @@ function M.Parser()
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
 			elseif it.re_name == "functionD_re" or it.re_name == "function_re" then
-				local stname = ""
+				--function_parse(self,it)
-				local namespace
-				if it.parent then
-					if it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" or it.parent.re_name == "class_re" then
-						stname = it.parent.name
-					elseif it.parent.re_name == "namespace_re" then
-						namespace = get_parents_nameC(it) --it.parent.name
-					end
-				end
-				if it.item:match"^%s*template%s+<" then
-					local ttype,fun = it.item:match"^%s*template%s+<%s*typename%s+([^>]+)%s*>%s*(.+)$"
-					if self.ftemplate_list and self.ftemplate_list[ttype] then
-						for iT,vT in ipairs(self.ftemplate_list[ttype]) do
-							local funT = fun:gsub("([< %(])"..ttype,"%1"..vT)
-							--funT = funT:gsub("sizeof%("..ttype.."%)","sizeof("..vT..")")
-							--local funT = fun:gsub(ttype,vT)
-							self:parseFunction(stname,{item=funT},namespace,it.locat)
-						end
-					end
-				else
-					self:parseFunction(stname,it,namespace,it.locat)
-				end
 			else
 				if it.re_name~="operator_re" then
 				print("not processed gen",it.re_name,it.item:sub(1,20))
@@ -1893,6 +2032,7 @@ function M.Parser()
 		check_arg_detection(self.defsT,self.typedefs_dict)
 		local outtabprest, outtabst = table.concat(outtabpre,""),table.concat(outtab,"")
 		self.structs_and_enums = {outtabprest, outtabst or ""}
+		
 		return outtabprest, outtabst
 	end
 	-----------
@@ -2086,7 +2226,9 @@ function M.Parser()
 				end
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
-			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" and it.re_name ~= "operator_re" then
+			elseif it.re_name ~= "functionD_re" or it.re_name ~= "function_re" then
+				function_parse(self,it)
+			elseif it.re_name ~= "operator_re" then
 				print("not processed gen table",it.re_name)
 			end
 		end
@@ -2683,7 +2825,8 @@ local function ImGui_f_implementation(def)
 		table.insert(outtab, "#endif\n")
     elseif def.nonUDT then
         if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = "..namespace..def.funcname..def.call_args..";\n")
+            --table.insert(outtab,"    *pOut = "..namespace..def.funcname..def.call_args..";\n")
+			insert(outtab,"    return ConverFromCPP_ImVec2("..namespace..def.funcname..def.call_args..");\n")
         end
 		table.insert(outtab,"}\n")
     else --standard ImGui
@@ -2717,7 +2860,9 @@ local function struct_f_implementation(def)
         end
     elseif def.nonUDT then
         if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
+            --table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
+			--local typret = (def.ret):gsub("const ","")
+			insert(outtab,"    return ConverFromCPP_"..def.conv.."(self->"..def.funcname..def.call_args..");\n")
         end
     else --standard struct
         table.insert(outtab,"    return "..ptret.."self->"..def.funcname..def.call_args..";\n")
@@ -2839,17 +2984,18 @@ local function func_header_generate_funcs(FP)
             elseif def.destructor then
                 table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
             else --not constructor
-
+				--local ret = FP.nP_ret[def.ret] or def.ret
+				local ret = def.ret
                 if def.stname == "" or def.is_static_function then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
+                    table.insert(outtab,"CIMGUI_API "..ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
 					if def.isvararg then
 						-- For variadic functions we add a function implementation with zero argumets, for compatibility with languages such as C#.
 						table.insert(outtab, "#ifdef CIMGUI_VARGS0\n")
-						table.insert(outtab, "CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname.."0"..paramListWithoutDots(def.args)..";\n")
+						table.insert(outtab, "CIMGUI_API".." "..ret.." "..def.ov_cimguiname.."0"..paramListWithoutDots(def.args)..";\n")
 						table.insert(outtab, "#endif\n")
 					end
                 else
-                    table.insert(outtab,"CIMGUI_API "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
+                    table.insert(outtab,"CIMGUI_API "..ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
                 end
             end 
         end

generator/generator.lua

@@ -124,10 +124,14 @@ local function func_header_impl_generate(FP)
 
     local outtab = {}
     
-    for _,t in ipairs(FP.funcdefs) do
+    -- for _,t in ipairs(FP.funcdefs) do
-        if t.cimguiname then
+        -- if t.cimguiname then
-            local cimf = FP.defsT[t.cimguiname]
+            -- local cimf = FP.defsT[t.cimguiname]
-            local def = cimf[t.signature]
+            -- local def = cimf[t.signature]
+		--for k,defs in pairs(FP.defsT) do
+		cpp2ffi.table_do_sorted(FP.defsT, function(i,defs)
+		   if true then
+		   for i, def in ipairs(defs) do
 			local addcoment = def.comment or ""
 			local empty = def.args:match("^%(%)") --no args
 			if def.constructor then
@@ -147,10 +151,11 @@ local function func_header_impl_generate(FP)
                     error("class function in implementations")
                 end
             end
+		end
         else --not cimguiname
             table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
         end
-    end
+    end)
     local cfuncsstr = table.concat(outtab)
     cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
     return cfuncsstr
@@ -272,6 +277,9 @@ local function cimgui_generation(parser)
 	--------------------------------------------------
     local hstrfile = read_data"./cimgui_template.h"
 	
+	
+	hstrfile = hstrfile:gsub([[PLACE_STRUCTS_C]],parser:gen_structs_c())
+	
 	local outpre,outpost = parser.structs_and_enums[1],parser.structs_and_enums[2]
 	cpp2ffi.prtable(parser.templates)
 	cpp2ffi.prtable(parser.typenames)
@@ -311,6 +319,9 @@ local function cimgui_generation(parser)
 	cimplem = colapse_defines(cimplem, "IMGUI_ENABLE_FREETYPE")
     local hstrfile = read_data"./cimgui_template.cpp"
 	
+	local conversors = parser:genConversors()
+	cimplem = conversors .. cimplem
+	
     hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
 	local ftdef = "" --FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
     save_data("./output/cimgui.cpp",cimgui_header, ftdef, hstrfile)