diff --git a/cimgui/cimgui.cpp b/cimgui/cimgui.cpp
index 51225e0..e01c0c8 100644
--- a/cimgui/cimgui.cpp
+++ b/cimgui/cimgui.cpp
@@ -2,6 +2,10 @@
 #include "../imgui/imgui.h"
 #include "cimgui.h"
 
+// to use placement new
+#define IMGUI_DEFINE_PLACEMENT_NEW
+#include "../imgui/imgui_internal.h"
+
 CIMGUI_API ImGuiIO* igGetIO()
 {
     return &ImGui::GetIO();
@@ -633,43 +637,43 @@ CIMGUI_API int igGetColumnsCount()
 // ID scopes
 // If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them
 // You can also use "##extra" within your widget name to distinguish them from each others (see 'Programmer Guide')
-CIMGUI_API void igPushIdStr(CONST char* str_id)
+CIMGUI_API void igPushIDStr(CONST char* str_id)
 {
     return ImGui::PushID(str_id);
 }
 
-CIMGUI_API void igPushIdStrRange(CONST char* str_begin, CONST char* str_end)
+CIMGUI_API void igPushIDStrRange(CONST char* str_begin, CONST char* str_end)
 {
     return ImGui::PushID(str_begin, str_end);
 }
 
 
-CIMGUI_API void igPushIdPtr(CONST void* ptr_id)
+CIMGUI_API void igPushIDPtr(CONST void* ptr_id)
 {
     return ImGui::PushID(ptr_id);
 }
 
-CIMGUI_API void igPushIdInt(int int_id)
+CIMGUI_API void igPushIDInt(int int_id)
 {
     return ImGui::PushID(int_id);
 }
 
-CIMGUI_API void igPopId()
+CIMGUI_API void igPopID()
 {
     return ImGui::PopID();
 }
 
-CIMGUI_API ImGuiID igGetIdStr(CONST char* str_id)
+CIMGUI_API ImGuiID igGetIDStr(CONST char* str_id)
 {
     return ImGui::GetID(str_id);
 }
 
-CIMGUI_API ImGuiID igGetIdStrRange(CONST char* str_begin, CONST char* str_end)
+CIMGUI_API ImGuiID igGetIDStrRange(CONST char* str_begin, CONST char* str_end)
 {
     return ImGui::GetID(str_begin, str_end);
 }
 
-CIMGUI_API ImGuiID igGetIdPtr(CONST void* ptr_id)
+CIMGUI_API ImGuiID igGetIDPtr(CONST void* ptr_id)
 {
     return ImGui::GetID(ptr_id);
 }
@@ -1277,7 +1281,7 @@ CIMGUI_API void igLogText(CONST char* fmt, ...)
     char buffer[256];
     va_list args;
     va_start(args, fmt);
-    snprintf(buffer, 256, fmt, args);
+    vsnprintf(buffer, 256, fmt, args);
     va_end(args);
 
     ImGui::LogText("%s",buffer);
@@ -1604,121 +1608,202 @@ CIMGUI_API void ImGuiIO_ClearInputCharacters()
     return ImGui::GetIO().ClearInputCharacters();
 }
 
-CIMGUI_API void	ImGuiTextFilter_Init(struct ImGuiTextFilter* filter, const char* default_filter)
+CIMGUI_API struct ImGuiTextFilter* ImGuiTextFilter_Create(const char* default_filter)
 {
-	*filter = ImGuiTextFilter(default_filter);
+    ImGuiTextFilter* filter = (ImGuiTextFilter*)ImGui::MemAlloc(sizeof(ImGuiTextFilter));
+    IM_PLACEMENT_NEW(filter) ImGuiTextFilter();
+    return filter;
 }
 
-CIMGUI_API void	ImGuiTextFilter_Clear(struct ImGuiTextFilter* filter)
+CIMGUI_API void ImGuiTextFilter_Destroy(struct ImGuiTextFilter* filter)
 {
-	filter->Clear();
+    filter->~ImGuiTextFilter();
+    ImGui::MemFree(filter);
 }
 
-CIMGUI_API bool	ImGuiTextFilter_Draw(struct ImGuiTextFilter* filter, const char* label, float width)
+CIMGUI_API void ImGuiTextFilter_Clear(struct ImGuiTextFilter* filter)
 {
-	return filter->Draw(label, width);
+    filter->Clear();
 }
 
-CIMGUI_API bool	ImGuiTextFilter_PassFilter(struct ImGuiTextFilter* filter, const char* text, const char* text_end)
+CIMGUI_API bool ImGuiTextFilter_Draw(struct ImGuiTextFilter* filter, const char* label, float width)
 {
-	return filter->PassFilter(text, text_end);
+    return filter->Draw(label, width);
 }
 
-CIMGUI_API bool	ImGuiTextFilter_IsActive(struct ImGuiTextFilter* filter)
+CIMGUI_API bool ImGuiTextFilter_PassFilter(const struct ImGuiTextFilter* filter, const char* text, const char* text_end)
 {
-	return filter->IsActive();
-}
-CIMGUI_API void	ImGuiTextFilter_Build(struct ImGuiTextFilter* filter)
-{
-	filter->Build();
+    return filter->PassFilter(text, text_end);
 }
 
-CIMGUI_API void ImGuiTextEditCallbackData_DeleteChars(struct ImGuiTextEditCallbackData* data, int pos, int bytes_count)
+CIMGUI_API bool ImGuiTextFilter_IsActive(const struct ImGuiTextFilter* filter)
 {
-	data->DeleteChars(pos, bytes_count);
+    return filter->IsActive();
 }
 
-CIMGUI_API void ImGuiTextEditCallbackData_InsertChars(struct ImGuiTextEditCallbackData* data, int pos, const char* text, const char* text_end)
+CIMGUI_API void ImGuiTextFilter_Build(struct ImGuiTextFilter* filter)
 {
-	data->InsertChars(pos, text, text_end);
+    filter->Build();
 }
 
-CIMGUI_API bool ImGuiTextEditCallbackData_HasSelection(struct ImGuiTextEditCallbackData* data)
+CIMGUI_API const char* ImGuiTextFilter_GetInputBuf(struct ImGuiTextFilter* filter)
 {
-	return data->HasSelection();
+    return filter->InputBuf;
 }
 
-CIMGUI_API void ImGuiStorage_Init(struct ImGuiStorage* storage)
+CIMGUI_API struct ImGuiTextBuffer* ImGuiTextBuffer_Create()
 {
-	*storage = ImGuiStorage();
+    ImGuiTextBuffer* buffer = (ImGuiTextBuffer*)ImGui::MemAlloc(sizeof(ImGuiTextBuffer));
+    IM_PLACEMENT_NEW(buffer) ImGuiTextBuffer();
+    return buffer;
+}
+
+CIMGUI_API void ImGuiTextBuffer_Destroy(struct ImGuiTextBuffer* buffer)
+{
+    buffer->~ImGuiTextBuffer();
+    ImGui::MemFree(buffer);
+}
+
+CIMGUI_API char ImGuiTextBuffer_index(struct ImGuiTextBuffer* buffer, int i)
+{
+    return (*buffer)[i];
+}
+
+CIMGUI_API const char* ImGuiTextBuffer_begin(const struct ImGuiTextBuffer* buffer)
+{
+    return buffer->begin();
+}
+
+CIMGUI_API const char* ImGuiTextBuffer_end(const struct ImGuiTextBuffer* buffer)
+{
+    return buffer->end();
+}
+
+CIMGUI_API int ImGuiTextBuffer_size(const struct ImGuiTextBuffer* buffer)
+{
+    return buffer->size();
+}
+
+CIMGUI_API bool ImGuiTextBuffer_empty(struct ImGuiTextBuffer* buffer)
+{
+    return buffer->empty();
+}
+
+CIMGUI_API void ImGuiTextBuffer_clear(struct ImGuiTextBuffer* buffer)
+{
+    buffer->clear();
+}
+
+CIMGUI_API const char* ImGuiTextBuffer_c_str(const struct ImGuiTextBuffer* buffer)
+{
+    return buffer->c_str();
+}
+
+CIMGUI_API void ImGuiTextBuffer_append(struct ImGuiTextBuffer* buffer, const char* fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    buffer->appendv(fmt, args);
+    va_end(args);
+}
+
+CIMGUI_API void ImGuiTextBuffer_appendv(struct ImGuiTextBuffer* buffer, const char* fmt, va_list args)
+{
+    buffer->appendv(fmt, args);
+}
+
+CIMGUI_API struct ImGuiStorage* ImGuiStorage_Create() {
+    ImGuiStorage* storage = (ImGuiStorage*)ImGui::MemAlloc(sizeof(ImGuiStorage));
+    IM_PLACEMENT_NEW(storage) ImGuiStorage();
+    return storage;
+}
+
+CIMGUI_API void ImGuiStorage_Destroy(struct ImGuiStorage* storage) {
+    storage->~ImGuiStorage();
+    ImGui::MemFree(storage);
 }
 
 CIMGUI_API void ImGuiStorage_Clear(struct ImGuiStorage* storage)
 {
-	storage->Clear();
+    storage->Clear();
 }
 
 CIMGUI_API int ImGuiStorage_GetInt(struct ImGuiStorage* storage, ImGuiID key, int default_val)
 {
-	return storage->GetInt(key, default_val);
+    return storage->GetInt(key, default_val);
 }
 
 CIMGUI_API void ImGuiStorage_SetInt(struct ImGuiStorage* storage, ImGuiID key, int val)
 {
-	storage->SetInt(key, val);
+    storage->SetInt(key, val);
 }
 
 CIMGUI_API bool ImGuiStorage_GetBool(struct ImGuiStorage* storage, ImGuiID key, bool default_val)
 {
-	return storage->GetBool(key, default_val);
+    return storage->GetBool(key, default_val);
 }
 
 CIMGUI_API void ImGuiStorage_SetBool(struct ImGuiStorage* storage, ImGuiID key, bool val)
 {
-	storage->SetBool(key, val);
+    storage->SetBool(key, val);
 }
 
 CIMGUI_API float ImGuiStorage_GetFloat(struct ImGuiStorage* storage, ImGuiID key, float default_val)
 {
-	return storage->GetFloat(key, default_val);
+    return storage->GetFloat(key, default_val);
 }
 
 CIMGUI_API void ImGuiStorage_SetFloat(struct ImGuiStorage* storage, ImGuiID key, float val)
 {
-	storage->SetFloat(key, val);
+    storage->SetFloat(key, val);
 }
 
 CIMGUI_API void* ImGuiStorage_GetVoidPtr(struct ImGuiStorage* storage, ImGuiID key)
 {
-	return storage->GetVoidPtr(key);
+    return storage->GetVoidPtr(key);
 }
 
 CIMGUI_API void ImGuiStorage_SetVoidPtr(struct ImGuiStorage* storage, ImGuiID key, void* val)
 {
-	storage->SetVoidPtr(key, val);
+    storage->SetVoidPtr(key, val);
 }
 
 CIMGUI_API int* ImGuiStorage_GetIntRef(struct ImGuiStorage* storage, ImGuiID key, int default_val)
 {
-	return storage->GetIntRef(key, default_val);
+    return storage->GetIntRef(key, default_val);
 }
 
 CIMGUI_API bool* ImGuiStorage_GetBoolRef(struct ImGuiStorage* storage, ImGuiID key, bool default_val)
 {
-	return storage->GetBoolRef(key, default_val);
+    return storage->GetBoolRef(key, default_val);
 }
 
 CIMGUI_API float* ImGuiStorage_GetFloatRef(struct ImGuiStorage* storage, ImGuiID key, float default_val)
 {
-	return storage->GetFloatRef(key, default_val);
+    return storage->GetFloatRef(key, default_val);
 }
 
 CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(struct ImGuiStorage* storage, ImGuiID key, void* default_val)
 {
-	return storage->GetVoidPtrRef(key, default_val);
+    return storage->GetVoidPtrRef(key, default_val);
 }
 
 CIMGUI_API void ImGuiStorage_SetAllInt(struct ImGuiStorage* storage, int val)
 {
-	storage->SetAllInt(val);
+    storage->SetAllInt(val);
+}
+
+CIMGUI_API void ImGuiTextEditCallbackData_DeleteChars(struct ImGuiTextEditCallbackData* data, int pos, int bytes_count)
+{
+    data->DeleteChars(pos, bytes_count);
+}
+
+CIMGUI_API void ImGuiTextEditCallbackData_InsertChars(struct ImGuiTextEditCallbackData* data, int pos, const char* text, const char* text_end)
+{
+    data->InsertChars(pos, text, text_end);
+}
+
+CIMGUI_API bool ImGuiTextEditCallbackData_HasSelection(struct ImGuiTextEditCallbackData* data)
+{
+    return data->HasSelection();
 }
diff --git a/cimgui/cimgui.h b/cimgui/cimgui.h
index 3996304..bb4b4d6 100644
--- a/cimgui/cimgui.h
+++ b/cimgui/cimgui.h
@@ -547,14 +547,14 @@ CIMGUI_API int              igGetColumnsCount();
 // ID scopes
 // If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them
 // You can also use "##extra" within your widget name to distinguish them from each others (see 'Programmer Guide')
-CIMGUI_API void             igPushIdStr(CONST char* str_id);
-CIMGUI_API void             igPushIdStrRange(CONST char* str_begin, CONST char* str_end);
-CIMGUI_API void             igPushIdPtr(CONST void* ptr_id);
-CIMGUI_API void             igPushIdInt(int int_id);
-CIMGUI_API void             igPopId();
-CIMGUI_API ImGuiID          igGetIdStr(CONST char* str_id);
-CIMGUI_API ImGuiID          igGetIdStrRange(CONST char* str_begin,CONST char* str_end);
-CIMGUI_API ImGuiID          igGetIdPtr(CONST void* ptr_id);
+CIMGUI_API void             igPushIDStr(CONST char* str_id);
+CIMGUI_API void             igPushIDStrRange(CONST char* str_begin, CONST char* str_end);
+CIMGUI_API void             igPushIDPtr(CONST void* ptr_id);
+CIMGUI_API void             igPushIDInt(int int_id);
+CIMGUI_API void             igPopID();
+CIMGUI_API ImGuiID          igGetIDStr(CONST char* str_id);
+CIMGUI_API ImGuiID          igGetIDStrRange(CONST char* str_begin,CONST char* str_end);
+CIMGUI_API ImGuiID          igGetIDPtr(CONST void* ptr_id);
 
 // Widgets
 CIMGUI_API void             igText(CONST char* fmt, ...);
@@ -773,47 +773,76 @@ CIMGUI_API CONST char*      igGetClipboardText();
 CIMGUI_API void             igSetClipboardText(CONST char* text);
 
 // Internal state access - if you want to share ImGui state between modules (e.g. DLL) or allocate it yourself
-CIMGUI_API CONST char*             igGetVersion();
-CIMGUI_API struct ImGuiContext*    igCreateContext(void* (*malloc_fn)(size_t), void (*free_fn)(void*));
-CIMGUI_API void                    igDestroyContext(struct ImGuiContext* ctx);
-CIMGUI_API struct ImGuiContext*    igGetCurrentContext();
-CIMGUI_API void                    igSetCurrentContext(struct ImGuiContext* ctx);
+CIMGUI_API CONST char*              igGetVersion();
+CIMGUI_API struct ImGuiContext*     igCreateContext(void* (*malloc_fn)(size_t), void (*free_fn)(void*));
+CIMGUI_API void                     igDestroyContext(struct ImGuiContext* ctx);
+CIMGUI_API struct ImGuiContext*     igGetCurrentContext();
+CIMGUI_API void                     igSetCurrentContext(struct ImGuiContext* ctx);
 
-CIMGUI_API void             ImFontConfig_DefaultConstructor(struct ImFontConfig* config);
+// ImGuiIO
+CIMGUI_API void                     ImGuiIO_AddInputCharacter(unsigned short c);
+CIMGUI_API void                     ImGuiIO_AddInputCharactersUTF8(CONST char* utf8_chars);
+CIMGUI_API void                     ImGuiIO_ClearInputCharacters();
 
-CIMGUI_API void             ImFontAtlas_GetTexDataAsRGBA32(struct ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
-CIMGUI_API void             ImFontAtlas_GetTexDataAsAlpha8(struct ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
-CIMGUI_API void             ImFontAtlas_SetTexID(struct ImFontAtlas* atlas, ImTextureID id);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFont(struct ImFontAtlas* atlas, CONST struct ImFontConfig* font_cfg);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFontDefault(struct ImFontAtlas* atlas, CONST struct ImFontConfig* font_cfg);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromFileTTF(struct ImFontAtlas* atlas, CONST char* filename, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryTTF(struct ImFontAtlas* atlas, void* font_data, int font_size, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryCompressedTTF(struct ImFontAtlas* atlas, CONST void* compressed_font_data, int compressed_font_size, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
-CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(struct ImFontAtlas* atlas, CONST char* compressed_font_data_base85, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
-CIMGUI_API void             ImFontAtlas_ClearTexData(struct ImFontAtlas* atlas);
-CIMGUI_API void             ImFontAtlas_Clear(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesDefault(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesKorean(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesJapanese(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesChinese(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesCyrillic(struct ImFontAtlas* atlas);
-CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesThai(struct ImFontAtlas* atlas);
+// ImGuiTextFilter
+CIMGUI_API struct ImGuiTextFilter*  ImGuiTextFilter_Create(const char* default_filter);
+CIMGUI_API void                     ImGuiTextFilter_Destroy(struct ImGuiTextFilter* filter);
+CIMGUI_API void                     ImGuiTextFilter_Clear(struct ImGuiTextFilter* filter);
+CIMGUI_API bool                     ImGuiTextFilter_Draw(struct ImGuiTextFilter* filter, const char* label, float width);
+CIMGUI_API bool                     ImGuiTextFilter_PassFilter(const struct ImGuiTextFilter* filter, const char* text, const char* text_end);
+CIMGUI_API bool                     ImGuiTextFilter_IsActive(const struct ImGuiTextFilter* filter);
+CIMGUI_API void                     ImGuiTextFilter_Build(struct ImGuiTextFilter* filter);
+CIMGUI_API const char*              ImGuiTextFilter_GetInputBuf(struct ImGuiTextFilter* filter);
 
-CIMGUI_API void             ImGuiIO_AddInputCharacter(unsigned short c);
-CIMGUI_API void             ImGuiIO_AddInputCharactersUTF8(CONST char* utf8_chars);
-CIMGUI_API void             ImGuiIO_ClearInputCharacters();
+// ImGuiTextBuffer
+CIMGUI_API struct ImGuiTextBuffer*  ImGuiTextBuffer_Create();
+CIMGUI_API void                     ImGuiTextBuffer_Destroy(struct ImGuiTextBuffer* buffer);
+CIMGUI_API char                     ImGuiTextBuffer_index(struct ImGuiTextBuffer* buffer, int i);
+CIMGUI_API const char*              ImGuiTextBuffer_begin(const struct ImGuiTextBuffer* buffer);
+CIMGUI_API const char*              ImGuiTextBuffer_end(const struct ImGuiTextBuffer* buffer);
+CIMGUI_API int                      ImGuiTextBuffer_size(const struct ImGuiTextBuffer* buffer);
+CIMGUI_API bool                     ImGuiTextBuffer_empty(struct ImGuiTextBuffer* buffer);
+CIMGUI_API void                     ImGuiTextBuffer_clear(struct ImGuiTextBuffer* buffer);
+CIMGUI_API const char*              ImGuiTextBuffer_c_str(const struct ImGuiTextBuffer* buffer);
+CIMGUI_API void                     ImGuiTextBuffer_append(struct ImGuiTextBuffer* buffer, const char* fmt, ...);
+CIMGUI_API void                     ImGuiTextBuffer_appendv(struct ImGuiTextBuffer* buffer, const char* fmt, va_list args);
 
-//ImDrawData
-CIMGUI_API void                 ImDrawData_DeIndexAllBuffers(struct ImDrawData* drawData);
-CIMGUI_API void					ImDrawData_ScaleClipRects(struct ImDrawData* drawData, struct ImVec2 sc);
+// ImGuiStorage
+CIMGUI_API struct ImGuiStorage*     ImGuiStorage_Create();
+CIMGUI_API void                     ImGuiStorage_Destroy(struct ImGuiStorage* storage);
+CIMGUI_API int                      ImGuiStorage_GetInt(struct ImGuiStorage* storage, ImGuiID key, int default_val);
+CIMGUI_API void                     ImGuiStorage_SetInt(struct ImGuiStorage* storage, ImGuiID key, int val);
+CIMGUI_API bool                     ImGuiStorage_GetBool(struct ImGuiStorage* storage, ImGuiID key, bool default_val);
+CIMGUI_API void                     ImGuiStorage_SetBool(struct ImGuiStorage* storage, ImGuiID key, bool val);
+CIMGUI_API float                    ImGuiStorage_GetFloat(struct ImGuiStorage* storage, ImGuiID key, float default_val);
+CIMGUI_API void                     ImGuiStorage_SetFloat(struct ImGuiStorage* storage, ImGuiID key, float val);
+CIMGUI_API void*                    ImGuiStorage_GetVoidPtr(struct ImGuiStorage* storage, ImGuiID key);
+CIMGUI_API void                     ImGuiStorage_SetVoidPtr(struct ImGuiStorage* storage, ImGuiID key, void* val);
+CIMGUI_API int*                     ImGuiStorage_GetIntRef(struct ImGuiStorage* storage, ImGuiID key, int default_val);
+CIMGUI_API bool*                    ImGuiStorage_GetBoolRef(struct ImGuiStorage* storage, ImGuiID key, bool default_val);
+CIMGUI_API float*                   ImGuiStorage_GetFloatRef(struct ImGuiStorage* storage, ImGuiID key, float default_val);
+CIMGUI_API void**                   ImGuiStorage_GetVoidPtrRef(struct ImGuiStorage* storage, ImGuiID key, void* default_val);
+CIMGUI_API void                     ImGuiStorage_SetAllInt(struct ImGuiStorage* storage, int val);
+
+// ImGuiTextEditCallbackData
+CIMGUI_API void                     ImGuiTextEditCallbackData_DeleteChars(struct ImGuiTextEditCallbackData* data, int pos, int bytes_count);
+CIMGUI_API void                     ImGuiTextEditCallbackData_InsertChars(struct ImGuiTextEditCallbackData* data, int pos, const char* text, const char* text_end);
+CIMGUI_API bool                     ImGuiTextEditCallbackData_HasSelection(struct ImGuiTextEditCallbackData* data);
+
+// ImGuiListClipper
+CIMGUI_API void                     ImGuiListClipper_Begin(struct ImGuiListClipper* clipper, int count, float items_height);
+CIMGUI_API void                     ImGuiListClipper_End(struct ImGuiListClipper* clipper);
+CIMGUI_API bool                     ImGuiListClipper_Step(struct ImGuiListClipper* clipper);
+CIMGUI_API int                      ImGuiListClipper_GetDisplayStart(struct ImGuiListClipper* clipper);
+CIMGUI_API int                      ImGuiListClipper_GetDisplayEnd(struct ImGuiListClipper* clipper);
 
 //ImDrawList
-CIMGUI_API int                  ImDrawList_GetVertexBufferSize(struct ImDrawList* list);
-CIMGUI_API struct ImDrawVert*   ImDrawList_GetVertexPtr(struct ImDrawList* list, int n);
-CIMGUI_API int                  ImDrawList_GetIndexBufferSize(struct ImDrawList* list);
-CIMGUI_API ImDrawIdx*           ImDrawList_GetIndexPtr(struct ImDrawList* list, int n);
-CIMGUI_API int                  ImDrawList_GetCmdSize(struct ImDrawList* list);
-CIMGUI_API struct ImDrawCmd*    ImDrawList_GetCmdPtr(struct ImDrawList* list, int n);
+CIMGUI_API int                      ImDrawList_GetVertexBufferSize(struct ImDrawList* list);
+CIMGUI_API struct ImDrawVert*       ImDrawList_GetVertexPtr(struct ImDrawList* list, int n);
+CIMGUI_API int                      ImDrawList_GetIndexBufferSize(struct ImDrawList* list);
+CIMGUI_API ImDrawIdx*               ImDrawList_GetIndexPtr(struct ImDrawList* list, int n);
+CIMGUI_API int                      ImDrawList_GetCmdSize(struct ImDrawList* list);
+CIMGUI_API struct ImDrawCmd*        ImDrawList_GetCmdPtr(struct ImDrawList* list, int n);
 
 CIMGUI_API void             ImDrawList_Clear(struct ImDrawList* list);
 CIMGUI_API void             ImDrawList_ClearFreeMemory(struct ImDrawList* list);
@@ -868,46 +897,83 @@ CIMGUI_API void             ImDrawList_AddDrawCmd(struct ImDrawList* list); // T
 CIMGUI_API void             ImDrawList_PrimReserve(struct ImDrawList* list, int idx_count, int vtx_count);
 CIMGUI_API void             ImDrawList_PrimRect(struct ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col);
 CIMGUI_API void             ImDrawList_PrimRectUV(struct ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, ImU32 col);
-CIMGUI_API void             ImDrawList_PrimQuadUV(struct ImDrawList* list,CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, CONST struct ImVec2 d, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, CONST struct ImVec2 uv_c, CONST struct ImVec2 uv_d, ImU32 col);
+CIMGUI_API void             ImDrawList_PrimQuadUV(struct ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, CONST struct ImVec2 d, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, CONST struct ImVec2 uv_c, CONST struct ImVec2 uv_d, ImU32 col);
 CIMGUI_API void             ImDrawList_PrimWriteVtx(struct ImDrawList* list, CONST struct ImVec2 pos, CONST struct ImVec2 uv, ImU32 col);
 CIMGUI_API void             ImDrawList_PrimWriteIdx(struct ImDrawList* list, ImDrawIdx idx);
 CIMGUI_API void             ImDrawList_PrimVtx(struct ImDrawList* list, CONST struct ImVec2 pos, CONST struct ImVec2 uv, ImU32 col);
 CIMGUI_API void             ImDrawList_UpdateClipRect(struct ImDrawList* list);
 CIMGUI_API void             ImDrawList_UpdateTextureID(struct ImDrawList* list);
 
-// ImGuiListClipper
-CIMGUI_API void ImGuiListClipper_Begin(struct ImGuiListClipper* clipper, int count, float items_height);
-CIMGUI_API void ImGuiListClipper_End(struct ImGuiListClipper* clipper);
-CIMGUI_API bool ImGuiListClipper_Step(struct ImGuiListClipper* clipper);
-CIMGUI_API int ImGuiListClipper_GetDisplayStart(struct ImGuiListClipper* clipper);
-CIMGUI_API int ImGuiListClipper_GetDisplayEnd(struct ImGuiListClipper* clipper);
+// ImDrawData
+CIMGUI_API void             ImDrawData_DeIndexAllBuffers(struct ImDrawData* drawData);
+CIMGUI_API void             ImDrawData_ScaleClipRects(struct ImDrawData* drawData, const struct ImVec2 sc);
 
-// ImGuiTextFilter
-CIMGUI_API void	ImGuiTextFilter_Init(struct ImGuiTextFilter* filter, const char* default_filter);
-CIMGUI_API void	ImGuiTextFilter_Clear(struct ImGuiTextFilter* filter);
-CIMGUI_API bool	ImGuiTextFilter_Draw(struct ImGuiTextFilter* filter, const char* label, float width);
-CIMGUI_API bool	ImGuiTextFilter_PassFilter(struct ImGuiTextFilter* filter, const char* text, const char* text_end);
-CIMGUI_API bool	ImGuiTextFilter_IsActive(struct ImGuiTextFilter* filter);
-CIMGUI_API void	ImGuiTextFilter_Build(struct ImGuiTextFilter* filter);
+// ImFontAtlas
+CIMGUI_API void             ImFontAtlas_GetTexDataAsRGBA32(struct ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
+CIMGUI_API void             ImFontAtlas_GetTexDataAsAlpha8(struct ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);
+CIMGUI_API void             ImFontAtlas_SetTexID(struct ImFontAtlas* atlas, ImTextureID id);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFont(struct ImFontAtlas* atlas, CONST struct ImFontConfig* font_cfg);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFontDefault(struct ImFontAtlas* atlas, CONST struct ImFontConfig* font_cfg);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromFileTTF(struct ImFontAtlas* atlas, CONST char* filename, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryTTF(struct ImFontAtlas* atlas, void* font_data, int font_size, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryCompressedTTF(struct ImFontAtlas* atlas, CONST void* compressed_font_data, int compressed_font_size, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
+CIMGUI_API struct ImFont*   ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(struct ImFontAtlas* atlas, CONST char* compressed_font_data_base85, float size_pixels, CONST struct ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges);
+CIMGUI_API void             ImFontAtlas_ClearTexData(struct ImFontAtlas* atlas);
+CIMGUI_API void             ImFontAtlas_Clear(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesDefault(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesKorean(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesJapanese(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesChinese(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesCyrillic(struct ImFontAtlas* atlas);
+CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesThai(struct ImFontAtlas* atlas);
 
-// ImGuiTextEditCallbackData
-CIMGUI_API void ImGuiTextEditCallbackData_DeleteChars(struct ImGuiTextEditCallbackData* data, int pos, int bytes_count);
-CIMGUI_API void ImGuiTextEditCallbackData_InsertChars(struct ImGuiTextEditCallbackData* data, int pos, const char* text, const char* text_end);
-CIMGUI_API bool ImGuiTextEditCallbackData_HasSelection(struct ImGuiTextEditCallbackData* data);
+CIMGUI_API ImTextureID      ImFontAtlas_GetTexID(struct ImFontAtlas* atlas);
+CIMGUI_API unsigned char*   ImFontAtlas_GetTexPixelsAlpha8(struct ImFontAtlas* atlas);
+CIMGUI_API unsigned int*    ImFontAtlas_GetTexPixelsRGBA32(struct ImFontAtlas* atlas);
+CIMGUI_API int              ImFontAtlas_GetTexWidth(struct ImFontAtlas* atlas);
+CIMGUI_API int              ImFontAtlas_GetTexHeight(struct ImFontAtlas* atlas);
+CIMGUI_API int              ImFontAtlas_GetTexDesiredWidth(struct ImFontAtlas* atlas);
+CIMGUI_API void             ImFontAtlas_SetTexDesiredWidth(struct ImFontAtlas* atlas, int TexDesiredWidth_);
+CIMGUI_API int              ImFontAtlas_GetTexGlyphPadding(struct ImFontAtlas* atlas);
+CIMGUI_API void             ImFontAtlas_SetTexGlyphPadding(struct ImFontAtlas* atlas, int TexGlyphPadding_);
+CIMGUI_API void             ImFontAtlas_GetTexUvWhitePixel(struct ImFontAtlas* atlas, ImVec2* pOut);
 
-// ImGuiStorage
-CIMGUI_API void ImGuiStorage_Init(struct ImGuiStorage* storage);
-CIMGUI_API void ImGuiStorage_Clear(struct ImGuiStorage* storage);
-CIMGUI_API int ImGuiStorage_GetInt(struct ImGuiStorage* storage, ImGuiID key, int default_val);
-CIMGUI_API void ImGuiStorage_SetInt(struct ImGuiStorage* storage, ImGuiID key, int val);
-CIMGUI_API bool ImGuiStorage_GetBool(struct ImGuiStorage* storage, ImGuiID key, bool default_val);
-CIMGUI_API void ImGuiStorage_SetBool(struct ImGuiStorage* storage, ImGuiID key, bool val);
-CIMGUI_API float ImGuiStorage_GetFloat(struct ImGuiStorage* storage, ImGuiID key, float default_val);
-CIMGUI_API void ImGuiStorage_SetFloat(struct ImGuiStorage* storage, ImGuiID key, float val);
-CIMGUI_API void* ImGuiStorage_GetVoidPtr(struct ImGuiStorage* storage, ImGuiID key);
-CIMGUI_API void ImGuiStorage_SetVoidPtr(struct ImGuiStorage* storage, ImGuiID key, void* val);
-CIMGUI_API int* ImGuiStorage_GetIntRef(struct ImGuiStorage* storage, ImGuiID key, int default_val);
-CIMGUI_API bool* ImGuiStorage_GetBoolRef(struct ImGuiStorage* storage, ImGuiID key, bool default_val);
-CIMGUI_API float* ImGuiStorage_GetFloatRef(struct ImGuiStorage* storage, ImGuiID key, float default_val);
-CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(struct ImGuiStorage* storage, ImGuiID key, void* default_val);
-CIMGUI_API void ImGuiStorage_SetAllInt(struct ImGuiStorage* storage, int val);
+// ImFontAtlas::Fonts;
+CIMGUI_API int              ImFontAtlas_Fonts_size(struct ImFontAtlas* atlas);
+CIMGUI_API ImFont*          ImFontAtlas_Fonts_index(struct ImFontAtlas* atlas, int index);
+
+// ImFont
+CIMGUI_API float            ImFont_GetFontSize(const struct ImFont* font);
+CIMGUI_API void             ImFont_SetFontSize(struct ImFont* font, float FontSize_);
+CIMGUI_API float            ImFont_GetScale(const struct ImFont* font);
+CIMGUI_API void             ImFont_SetScale(struct ImFont* font, float Scale_);
+CIMGUI_API void             ImFont_GetDisplayOffset(const struct ImFont* font, ImVec2* pOut);
+CIMGUI_API const struct ImFont::Glyph* ImFont_GetFallbackGlyph(const struct ImFont* font);
+CIMGUI_API void             ImFont_SetFallbackGlyph(struct ImFont* font, const struct ImFont::Glyph* FallbackGlyph_);
+CIMGUI_API float            ImFont_GetFallbackXAdvance(const struct ImFont* font);
+CIMGUI_API ImWchar          ImFont_GetFallbackChar(const struct ImFont* font);
+CIMGUI_API short            ImFont_GetConfigDataCount(const struct ImFont* font);
+CIMGUI_API struct ImFontConfig* ImFont_GetConfigData(struct ImFont* font);
+CIMGUI_API struct ImFontAtlas* ImFont_GetContainerAtlas(struct ImFont* font);
+CIMGUI_API float            ImFont_GetAscent(const struct ImFont* font);
+CIMGUI_API float            ImFont_GetDescent(const struct ImFont* font);
+CIMGUI_API int              ImFont_GetMetricsTotalSurface(const struct ImFont* font);
+CIMGUI_API void             ImFont_Clear(struct ImFont* font);
+CIMGUI_API void             ImFont_BuildLookupTable(struct ImFont* font);
+CIMGUI_API const struct ImFont::Glyph* ImFont_FindGlyph(const struct ImFont* font, ImWchar c);
+CIMGUI_API void             ImFont_SetFallbackChar(struct ImFont* font, ImWchar c);
+CIMGUI_API float            ImFont_GetCharAdvance(const struct ImFont* font, ImWchar c);
+CIMGUI_API bool             ImFont_IsLoaded(const struct ImFont* font);
+CIMGUI_API void             ImFont_CalcTextSizeA(const struct ImFont* font, ImVec2* pOut, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL); // utf8
+CIMGUI_API const char*      ImFont_CalcWordWrapPositionA(const struct ImFont* font, float scale, const char* text, const char* text_end, float wrap_width);
+CIMGUI_API void             ImFont_RenderChar(const struct ImFont* font, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, unsigned short c);
+CIMGUI_API void             ImFont_RenderText(const struct ImFont* font, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4* clip_rect, const char* text_begin, const char* text_end, float wrap_width = 0.0f, bool cpu_fine_clip = false);
+// ImFont::Glyph
+CIMGUI_API int              ImFont_Glyphs_size(const struct ImFont* font);
+CIMGUI_API struct ImFont::Glyph* ImFont_Glyphs_index(struct ImFont* font, int index);
+// ImFont::IndexXAdvance
+CIMGUI_API int              ImFont_IndexXAdvance_size(const struct ImFont* font);
+CIMGUI_API float            ImFont_IndexXAdvance_index(const struct ImFont* font, int index);
+// ImFont::IndexLookup
+CIMGUI_API int              ImFont_IndexLookup_size(const struct ImFont* font);
+CIMGUI_API unsigned short   ImFont_IndexLookup_index(const struct ImFont* font, int index);
diff --git a/cimgui/drawList.cpp b/cimgui/drawList.cpp
index c9a71d4..9307495 100644
--- a/cimgui/drawList.cpp
+++ b/cimgui/drawList.cpp
@@ -2,287 +2,287 @@
 #include "../imgui/imgui.h"
 #include "cimgui.h"
 
+CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* drawData)
+{
+    return drawData->DeIndexAllBuffers();
+}
+
+CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* drawData, const struct ImVec2 sc)
+{
+    return drawData->ScaleClipRects(sc);
+}
+
 CIMGUI_API int ImDrawList_GetVertexBufferSize(ImDrawList* list)
 {
-	return list->VtxBuffer.size();
+    return list->VtxBuffer.size();
 }
 
 CIMGUI_API ImDrawVert* ImDrawList_GetVertexPtr(ImDrawList* list, int n)
 {
-	return &list->VtxBuffer[n];
+    return &list->VtxBuffer[n];
 }
 
 CIMGUI_API int ImDrawList_GetIndexBufferSize(ImDrawList* list)
 {
-	return list->IdxBuffer.size();
+    return list->IdxBuffer.size();
 }
 
 CIMGUI_API ImDrawIdx* ImDrawList_GetIndexPtr(ImDrawList* list, int n)
 {
-	return &list->IdxBuffer[n];
+    return &list->IdxBuffer[n];
 }
 
 CIMGUI_API int ImDrawList_GetCmdSize(ImDrawList* list)
 {
-	return list->CmdBuffer.size();
+    return list->CmdBuffer.size();
 }
 
 CIMGUI_API ImDrawCmd* ImDrawList_GetCmdPtr(ImDrawList* list, int n)
 {
-	return &list->CmdBuffer[n];
-}
-
-CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* drawData)
-{
-	return drawData->DeIndexAllBuffers();
-}
-
-CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* drawData, struct ImVec2 sc)
-{
-	return drawData->ScaleClipRects(sc);
+    return &list->CmdBuffer[n];
 }
 
 CIMGUI_API void ImDrawList_Clear(ImDrawList* list)
 {
-	return list->Clear();
+    return list->Clear();
 }
 
 CIMGUI_API void ImDrawList_ClearFreeMemory(ImDrawList* list)
 {
-	return list->ClearFreeMemory();
+    return list->ClearFreeMemory();
 }
 
 CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* list, struct ImVec2 clip_rect_min, struct ImVec2 clip_rect_max, bool intersect_with_current_clip_rect)
 {
-	return list->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
+    return list->PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect);
 }
 
 CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* list)
 {
-	return list->PushClipRectFullScreen();
+    return list->PushClipRectFullScreen();
 }
 
 CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* list)
 {
-	return list->PopClipRect();
+    return list->PopClipRect();
 }
 
 CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* list, CONST ImTextureID texture_id)
 {
-	return list->PushTextureID(texture_id);
+    return list->PushTextureID(texture_id);
 }
 
 CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* list)
 {
-	return list->PopTextureID();
+    return list->PopTextureID();
 }
 
 CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2* pOut, ImDrawList* list)
 {
-	*pOut = list->GetClipRectMin();
+    *pOut = list->GetClipRectMin();
 }
 
 CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2* pOut, ImDrawList* list)
 {
-	*pOut = list->GetClipRectMax();
+    *pOut = list->GetClipRectMax();
 }
 
 CIMGUI_API void ImDrawList_AddLine(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col, float thickness)
 {
-	return list->AddLine(a, b, col, thickness);
+    return list->AddLine(a, b, col, thickness);
 }
 
 CIMGUI_API void ImDrawList_AddRect(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col, float rounding, int rounding_corners_flags, float thickness)
 {
-	return list->AddRect(a, b, col, rounding, rounding_corners_flags, thickness);
+    return list->AddRect(a, b, col, rounding, rounding_corners_flags, thickness);
 }
 
 CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col, float rounding, int rounding_corners_flags)
 {
-	return list->AddRectFilled(a, b, col, rounding, rounding_corners_flags);
+    return list->AddRectFilled(a, b, col, rounding, rounding_corners_flags);
 }
 
 CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
 {
-	return list->AddRectFilledMultiColor(a, b, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
+    return list->AddRectFilledMultiColor(a, b, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
 }
 
 CIMGUI_API void ImDrawList_AddQuad(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, CONST struct ImVec2 d, ImU32 col, float thickness)
 {
-	return list->AddQuad(a, b, c, d, col, thickness);
+    return list->AddQuad(a, b, c, d, col, thickness);
 }
 
 CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, CONST struct ImVec2 d, ImU32 col)
 {
-	return list->AddQuadFilled(a, b, c, d, col);
+    return list->AddQuadFilled(a, b, c, d, col);
 }
 
 CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, ImU32 col, float thickness)
 {
-	return list->AddTriangle(a,b,c,col,thickness);
+    return list->AddTriangle(a,b,c,col,thickness);
 }
 
 CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, ImU32 col)
 {
-	return list->AddTriangleFilled(a, b, c, col);
+    return list->AddTriangleFilled(a, b, c, col);
 }
 
 CIMGUI_API void ImDrawList_AddCircle(ImDrawList* list, CONST struct ImVec2 centre, float radius, ImU32 col, int num_segments, float thickness)
 {
-	return list->AddCircle(centre, radius, col, num_segments, thickness);
+    return list->AddCircle(centre, radius, col, num_segments, thickness);
 }
 
 CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* list, CONST struct ImVec2 centre, float radius, ImU32 col, int num_segments)
 {
-	return list->AddCircleFilled(centre, radius, col, num_segments);
+    return list->AddCircleFilled(centre, radius, col, num_segments);
 }
 
 CIMGUI_API void ImDrawList_AddText(ImDrawList* list, CONST struct ImVec2 pos, ImU32 col, CONST char* text_begin, CONST char* text_end)
 {
-	return list->AddText(pos, col, text_begin, text_end);
+    return list->AddText(pos, col, text_begin, text_end);
 }
 
 CIMGUI_API void ImDrawList_AddTextExt(ImDrawList* list, CONST ImFont* font, float font_size, CONST struct ImVec2 pos, ImU32 col, CONST char* text_begin, CONST char* text_end, float wrap_width, CONST ImVec4* cpu_fine_clip_rect)
 {
-	return list->AddText(font, font_size, pos, col, text_begin, text_end, wrap_width, cpu_fine_clip_rect);
+    return list->AddText(font, font_size, pos, col, text_begin, text_end, wrap_width, cpu_fine_clip_rect);
 }
 
 CIMGUI_API void ImDrawList_AddImage(ImDrawList* list, ImTextureID user_texture_id, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, ImU32 col)
 {
-	return list->AddImage(user_texture_id, a, b, uv_a, uv_b, col);
+    return list->AddImage(user_texture_id, a, b, uv_a, uv_b, col);
 }
 
 CIMGUI_API void ImDrawList_AddImageQuad(struct ImDrawList* list, ImTextureID user_texture_id, CONST struct ImVec2 a, CONST ImVec2 b, CONST ImVec2 c, CONST ImVec2 d, CONST ImVec2 uv_a, CONST ImVec2 uv_b, CONST ImVec2 uv_c, CONST ImVec2 uv_d, ImU32 col)
 {
-	return list->AddImageQuad(user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
+    return list->AddImageQuad(user_texture_id, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
 }
 
 CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* list, CONST ImVec2* points, CONST int num_points, ImU32 col, bool closed, float thickness, bool anti_aliased)
 {
-	return list->AddPolyline(points, num_points, col, closed, thickness, anti_aliased);
+    return list->AddPolyline(points, num_points, col, closed, thickness, anti_aliased);
 }
 
 CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* list, CONST ImVec2* points, CONST int num_points, ImU32 col, bool anti_aliased)
 {
-	return list->AddConvexPolyFilled(points, num_points, col, anti_aliased);
+    return list->AddConvexPolyFilled(points, num_points, col, anti_aliased);
 }
 
 CIMGUI_API void ImDrawList_AddBezierCurve(ImDrawList* list, CONST struct ImVec2 pos0, CONST struct ImVec2 cp0, CONST struct ImVec2 cp1, CONST struct ImVec2 pos1, ImU32 col, float thickness, int num_segments)
 {
-	return list->AddBezierCurve(pos0, cp0, cp1, pos1, col, thickness, num_segments);
+    return list->AddBezierCurve(pos0, cp0, cp1, pos1, col, thickness, num_segments);
 }
 
 CIMGUI_API void ImDrawList_PathClear(ImDrawList* list)
 {
-	return list->PathClear();
+    return list->PathClear();
 }
 
 CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* list, CONST struct ImVec2 pos)
 {
-	return list->PathLineTo(pos);
+    return list->PathLineTo(pos);
 }
 
 CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* list, CONST struct ImVec2 pos)
 {
-	return list->PathLineToMergeDuplicate(pos);
+    return list->PathLineToMergeDuplicate(pos);
 }
 
 CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* list, ImU32 col)
 {
-	return list->PathFillConvex(col);
+    return list->PathFillConvex(col);
 }
 
 CIMGUI_API void ImDrawList_PathStroke(ImDrawList* list, ImU32 col, bool closed, float thickness)
 {
-	return list->PathStroke(col, closed, thickness);
+    return list->PathStroke(col, closed, thickness);
 }
 
 CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* list, CONST struct ImVec2 centre, float radius, float a_min, float a_max, int num_segments)
 {
-	return list->PathArcTo(centre, radius, a_min, a_max, num_segments);
+    return list->PathArcTo(centre, radius, a_min, a_max, num_segments);
 }
 
 CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* list, CONST struct ImVec2 centre, float radius, int a_min_of_12, int a_max_of_12)
 {
-	return list->PathArcToFast(centre, radius, a_min_of_12, a_max_of_12);
+    return list->PathArcToFast(centre, radius, a_min_of_12, a_max_of_12);
 }
 
 CIMGUI_API void ImDrawList_PathBezierCurveTo(ImDrawList* list, CONST struct ImVec2 p1, CONST struct ImVec2 p2, CONST struct ImVec2 p3, int num_segments)
 {
-	return list->PathBezierCurveTo(p1, p2, p3, num_segments);
+    return list->PathBezierCurveTo(p1, p2, p3, num_segments);
 }
 
 CIMGUI_API void ImDrawList_PathRect(ImDrawList* list, CONST struct ImVec2 rect_min, CONST struct ImVec2 rect_max, float rounding, int rounding_corners_flags)
 {
-	return list->PathRect(rect_min, rect_max, rounding, rounding_corners_flags);
+    return list->PathRect(rect_min, rect_max, rounding, rounding_corners_flags);
 }
 
 CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* list, int channels_count)
 {
-	return list->ChannelsSplit(channels_count);
+    return list->ChannelsSplit(channels_count);
 }
 
 CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* list)
 {
-	return list->ChannelsMerge();
+    return list->ChannelsMerge();
 }
 
 CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* list, int channel_index)
 {
-	return list->ChannelsSetCurrent(channel_index);
+    return list->ChannelsSetCurrent(channel_index);
 }
 
 CIMGUI_API void ImDrawList_AddCallback(ImDrawList* list, ImDrawCallback callback, void* callback_data)
 {
-	return list->AddCallback(callback, callback_data);
+    return list->AddCallback(callback, callback_data);
 }
 
 CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* list)
 {
-	return list->AddDrawCmd();
+    return list->AddDrawCmd();
 }
 
 CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* list, int idx_count, int vtx_count)
 {
-	return list->PrimReserve(idx_count, vtx_count);
+    return list->PrimReserve(idx_count, vtx_count);
 }
 
 CIMGUI_API void ImDrawList_PrimRect(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, ImU32 col)
 {
-	return list->PrimRect(a, b, col);
+    return list->PrimRect(a, b, col);
 }
 
 CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* list, CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, ImU32 col)
 {
-	return list->PrimRectUV(a, b, uv_a, uv_b, col);
+    return list->PrimRectUV(a, b, uv_a, uv_b, col);
 }
 
 CIMGUI_API void ImDrawList_PrimQuadUV(ImDrawList* list,CONST struct ImVec2 a, CONST struct ImVec2 b, CONST struct ImVec2 c, CONST struct ImVec2 d, CONST struct ImVec2 uv_a, CONST struct ImVec2 uv_b, CONST struct ImVec2 uv_c, CONST struct ImVec2 uv_d, ImU32 col)
 {
-	return list->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
+    return list->PrimQuadUV(a,b,c,d,uv_a,uv_b,uv_c,uv_d,col);
 }
 
 CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* list, CONST struct ImVec2 pos, CONST struct ImVec2 uv, ImU32 col)
 {
-	return list->PrimVtx(pos, uv, col);
+    return list->PrimVtx(pos, uv, col);
 }
 
 CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* list, CONST struct ImVec2 pos, CONST struct ImVec2 uv, ImU32 col)
 {
-	return list->PrimWriteVtx(pos, uv, col);
+    return list->PrimWriteVtx(pos, uv, col);
 }
 
 CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* list, ImDrawIdx idx)
 {
-	return list->PrimWriteIdx(idx);
+    return list->PrimWriteIdx(idx);
 }
 
 CIMGUI_API void ImDrawList_UpdateClipRect(ImDrawList* list)
 {
-	return list->UpdateClipRect();
+    return list->UpdateClipRect();
 }
 
 CIMGUI_API void ImDrawList_UpdateTextureID(ImDrawList* list)
 {
-	return list->UpdateTextureID();
+    return list->UpdateTextureID();
 }
diff --git a/cimgui/fontAtlas.cpp b/cimgui/fontAtlas.cpp
index 5c79d8a..c0bcd21 100644
--- a/cimgui/fontAtlas.cpp
+++ b/cimgui/fontAtlas.cpp
@@ -2,92 +2,317 @@
 #include "../imgui/imgui.h"
 #include "cimgui.h"
 
-CIMGUI_API void ImFontConfig_DefaultConstructor(ImFontConfig* config)
-{
-	*config = ImFontConfig();
-}
-
 CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
 {
-	atlas->GetTexDataAsRGBA32(out_pixels, out_width, out_height, out_bytes_per_pixel);
+    atlas->GetTexDataAsRGBA32(out_pixels, out_width, out_height, out_bytes_per_pixel);
 }
 
 CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* atlas, unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
 {
-	atlas->GetTexDataAsAlpha8(out_pixels, out_width, out_height, out_bytes_per_pixel);
+    atlas->GetTexDataAsAlpha8(out_pixels, out_width, out_height, out_bytes_per_pixel);
 }
 
 CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* atlas, ImTextureID id)
 {
-	atlas->TexID = id;
+    atlas->TexID = id;
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* atlas, CONST ImFontConfig* font_cfg)
 {
-	return atlas->AddFont(font_cfg);
+    return atlas->AddFont(font_cfg);
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* atlas, CONST ImFontConfig* font_cfg)
 {
-	return atlas->AddFontDefault(font_cfg);
+    return atlas->AddFontDefault(font_cfg);
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* atlas,CONST char* filename, float size_pixels, CONST ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges)
 {
-	return atlas->AddFontFromFileTTF(filename, size_pixels, font_cfg, glyph_ranges);
+    return atlas->AddFontFromFileTTF(filename, size_pixels, font_cfg, glyph_ranges);
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* atlas, void* font_data, int font_size, float size_pixels, CONST ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges)
 {
-	return atlas->AddFontFromMemoryTTF(font_data, font_size, size_pixels, font_cfg, glyph_ranges);
+    return atlas->AddFontFromMemoryTTF(font_data, font_size, size_pixels, font_cfg, glyph_ranges);
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* atlas, CONST void* compressed_font_data, int compressed_font_size, float size_pixels, CONST ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges)
 {
-	return atlas->AddFontFromMemoryCompressedTTF(compressed_font_data, compressed_font_size, size_pixels, font_cfg, glyph_ranges);
+    return atlas->AddFontFromMemoryCompressedTTF(compressed_font_data, compressed_font_size, size_pixels, font_cfg, glyph_ranges);
 }
 
 CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* atlas, CONST char* compressed_font_data_base85, float size_pixels, CONST ImFontConfig* font_cfg, CONST ImWchar* glyph_ranges)
 {
-	return atlas->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
+    return atlas->AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
 }
 
 CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* atlas)
 {
-	return atlas->ClearTexData();
+    return atlas->ClearTexData();
+}
+
+CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* atlas)
+{
+    return atlas->ClearInputData();
+}
+
+CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* atlas)
+{
+    return atlas->ClearFonts();
 }
 
 CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* atlas)
 {
-	return atlas->Clear();
+    return atlas->Clear();
 }
 
 CIMGUI_API CONST ImWchar* ImFontAtlas_GetGlyphRangesDefault(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesDefault();
+    return atlas->GetGlyphRangesDefault();
 }
 
 CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesKorean(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesKorean();
+    return atlas->GetGlyphRangesKorean();
 }
 
 CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesJapanese(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesJapanese();
+    return atlas->GetGlyphRangesJapanese();
 }
 
 CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesChinese(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesChinese();
+    return atlas->GetGlyphRangesChinese();
 }
 
 CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesCyrillic(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesCyrillic();
+    return atlas->GetGlyphRangesCyrillic();
 }
 
 CIMGUI_API CONST ImWchar*   ImFontAtlas_GetGlyphRangesThai(struct ImFontAtlas* atlas)
 {
-	return atlas->GetGlyphRangesThai();
+    return atlas->GetGlyphRangesThai();
+}
+
+CIMGUI_API ImTextureID ImFontAtlas_GetTexID(struct ImFontAtlas* atlas)
+{
+    return atlas->TexID;
+}
+
+CIMGUI_API unsigned char* ImFontAtlas_GetTexPixelsAlpha8(struct ImFontAtlas* atlas)
+{
+    return atlas->TexPixelsAlpha8;
+}
+
+CIMGUI_API unsigned int* ImFontAtlas_GetTexPixelsRGBA32(struct ImFontAtlas* atlas)
+{
+    return atlas->TexPixelsRGBA32;
+}
+
+CIMGUI_API int ImFontAtlas_GetTexWidth(struct ImFontAtlas* atlas)
+{
+    return atlas->TexWidth;
+}
+
+CIMGUI_API int ImFontAtlas_GetTexHeight(struct ImFontAtlas* atlas)
+{
+    return atlas->TexHeight;
+}
+
+CIMGUI_API int ImFontAtlas_GetTexDesiredWidth(struct ImFontAtlas* atlas)
+{
+    return atlas->TexDesiredWidth;
+}
+
+CIMGUI_API void ImFontAtlas_SetTexDesiredWidth(struct ImFontAtlas* atlas, int TexDesiredWidth_)
+{
+    atlas->TexDesiredWidth = TexDesiredWidth_;
+}
+
+CIMGUI_API int ImFontAtlas_GetTexGlyphPadding(struct ImFontAtlas* atlas)
+{
+    return atlas->TexGlyphPadding;
+}
+
+CIMGUI_API void ImFontAtlas_SetTexGlyphPadding(struct ImFontAtlas* atlas, int TexGlyphPadding_)
+{
+    atlas->TexGlyphPadding = TexGlyphPadding_;
+}
+
+CIMGUI_API void ImFontAtlas_GetTexUvWhitePixel(struct ImFontAtlas* atlas, ImVec2* pOut)
+{
+    *pOut = atlas->TexUvWhitePixel;
+}
+
+// ImFontAtlas::Fonts;
+CIMGUI_API int ImFontAtlas_Fonts_size(struct ImFontAtlas* atlas)
+{
+    return atlas->Fonts.size();
+}
+
+CIMGUI_API ImFont* ImFontAtlas_Fonts_index(struct ImFontAtlas* atlas, int index)
+{
+    return atlas->Fonts[index];
+}
+
+// ImFont
+CIMGUI_API float ImFont_GetFontSize(const struct ImFont* font)
+{
+    return font->FontSize;
+}
+
+CIMGUI_API void ImFont_SetFontSize(struct ImFont* font, float FontSize_)
+{
+    font->FontSize = FontSize_;
+}
+
+CIMGUI_API float ImFont_GetScale(const struct ImFont* font)
+{
+    return font->Scale;
+}
+
+CIMGUI_API void ImFont_SetScale(struct ImFont* font, float Scale_)
+{
+    font->Scale = Scale_;
+}
+
+CIMGUI_API void ImFont_GetDisplayOffset(const struct ImFont* font, ImVec2* pOut)
+{
+    *pOut = font->DisplayOffset;
+}
+
+CIMGUI_API const struct ImFont::Glyph* ImFont_GetFallbackGlyph(const struct ImFont* font)
+{
+    return font->FallbackGlyph;
+}
+
+CIMGUI_API void ImFont_SetFallbackGlyph(struct ImFont* font, const struct ImFont::Glyph* FallbackGlyph_)
+{
+    font->FallbackGlyph = FallbackGlyph_;
+}
+
+CIMGUI_API float ImFont_GetFallbackXAdvance(const struct ImFont* font)
+{
+    return font->FallbackXAdvance;
+}
+
+CIMGUI_API ImWchar ImFont_GetFallbackChar(const struct ImFont* font)
+{
+    return font->FallbackChar;
+}
+
+CIMGUI_API short ImFont_GetConfigDataCount(const struct ImFont* font)
+{
+    return font->ConfigDataCount;
+}
+
+CIMGUI_API struct ImFontConfig* ImFont_GetConfigData(struct ImFont* font)
+{
+    return font->ConfigData;
+}
+
+CIMGUI_API struct ImFontAtlas* ImFont_GetContainerAtlas(struct ImFont* font)
+{
+    return font->ContainerAtlas;
+}
+
+CIMGUI_API float ImFont_GetAscent(const struct ImFont* font)
+{
+    return font->Ascent;
+}
+
+CIMGUI_API float ImFont_GetDescent(const struct ImFont* font)
+{
+    return font->Descent;
+}
+
+CIMGUI_API int ImFont_GetMetricsTotalSurface(const struct ImFont* font)
+{
+    return font->MetricsTotalSurface;
+}
+
+CIMGUI_API void ImFont_Clear(struct ImFont* font)
+{
+    font->Clear();
+}
+
+CIMGUI_API void ImFont_BuildLookupTable(struct ImFont* font)
+{
+    font->BuildLookupTable();
+}
+
+CIMGUI_API const struct ImFont::Glyph* ImFont_FindGlyph(const struct ImFont* font, ImWchar c)
+{
+    return font->FindGlyph(c);
+}
+
+CIMGUI_API void ImFont_SetFallbackChar(struct ImFont* font, ImWchar c)
+{
+    font->SetFallbackChar(c);
+}
+
+CIMGUI_API float ImFont_GetCharAdvance(const struct ImFont* font, ImWchar c)
+{
+    return font->GetCharAdvance(c);
+}
+
+CIMGUI_API bool ImFont_IsLoaded(const struct ImFont* font)
+{
+    return font->IsLoaded();
+}
+
+CIMGUI_API void ImFont_CalcTextSizeA(const struct ImFont* font, ImVec2* pOut, float size, float max_width, float wrap_width, const char* text_begin, const char* text_end, const char** remaining)
+{
+    *pOut = font->CalcTextSizeA(size, max_width, wrap_width, text_begin, text_end, remaining);
+}
+
+CIMGUI_API const char* ImFont_CalcWordWrapPositionA(const struct ImFont* font, float scale, const char* text, const char* text_end, float wrap_width)
+{
+    return font->CalcWordWrapPositionA(scale, text, text_end, wrap_width);
+}
+
+CIMGUI_API void ImFont_RenderChar(const struct ImFont* font, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, unsigned short c)
+{
+    return font->RenderChar(draw_list, size, pos, col, c);
+}
+
+CIMGUI_API void ImFont_RenderText(const struct ImFont* font, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4* clip_rect, const char* text_begin, const char* text_end, float wrap_width, bool cpu_fine_clip)
+{
+    return font->RenderText(draw_list, size, pos, col, *clip_rect, text_begin, text_end, wrap_width, cpu_fine_clip);
+}
+
+// ImFont::Glyph
+CIMGUI_API int ImFont_Glyphs_size(const struct ImFont* font)
+{
+    return font->Glyphs.size();
+}
+
+CIMGUI_API struct ImFont::Glyph* ImFont_Glyphs_index(struct ImFont* font, int index)
+{
+    return &font->Glyphs[index];
+}
+
+// ImFont::IndexXAdvance
+CIMGUI_API int ImFont_IndexXAdvance_size(const struct ImFont* font)
+{
+    return font->IndexXAdvance.size();
+}
+
+CIMGUI_API float ImFont_IndexXAdvance_index(const struct ImFont* font, int index)
+{
+    return font->IndexXAdvance[index];
+}
+
+// ImFont::IndexLookup
+CIMGUI_API int ImFont_IndexLookup_size(const struct ImFont* font)
+{
+    return font->IndexLookup.size();
+}
+
+CIMGUI_API unsigned short ImFont_IndexLookup_index(const struct ImFont* font, int index)
+{
+    return font->IndexLookup[index];
 }