start merging sokol_gfx_cimgui.h into sokol_gfx_imgui.h

1 files changed, 366 insertions, 279 deletions

diff --git a/util/sokol_gfx_imgui.h b/util/sokol_gfx_imgui.h
index b4926ffa..6f0c3de6 100644
--- a/util/sokol_gfx_imgui.h
+++ b/util/sokol_gfx_imgui.h
@@ -579,8 +579,14 @@ SOKOL_API_DECL void sg_imgui_draw_capabilities_window(sg_imgui_t* ctx);
 
 /*=== IMPLEMENTATION =========================================================*/
 #if defined SOKOL_GFX_IMGUI_IMPL
-#if !defined(IMGUI_VERSION)
-#error "Please include imgui.h before the sokol_gfx_imgui.h implementation"
+#if defined(__cplusplus)
+    #if !defined(IMGUI_VERSION)
+    #error "Please include imgui.h before the sokol_imgui.h implementation"
+    #endif
+#else
+    #if !defined(CIMGUI_INCLUDED)
+    #error "Please include cimgui.h before the sokol_imgui.h implementation"
+    #endif
 #endif
 #ifndef SOKOL_ASSERT
     #include <assert.h>
@@ -610,10 +616,91 @@ SOKOL_API_DECL void sg_imgui_draw_capabilities_window(sg_imgui_t* ctx);
 
 #define _SG_IMGUI_SLOT_MASK (0xFFFF)
 #define _SG_IMGUI_LIST_WIDTH (192)
-#define _SG_IMGUI_COLOR_OTHER ImColor(0.75f, 0.75f, 0.75f, 1.0f)
-#define _SG_IMGUI_COLOR_RSRC ImColor(1.0f, 1.0f, 0.0f, 1.0f)
-#define _SG_IMGUI_COLOR_DRAW ImColor(0.0f, 1.0f, 0.0f, 1.0f)
-#define _SG_IMGUI_COLOR_ERR ImColor(1.0f, 0.5f, 0.5f, 1.0f)
+#define _SG_IMGUI_COLOR_OTHER 0xFFCCCCCC
+#define _SG_IMGUI_COLOR_RSRC 0xFF00FFFF
+#define _SG_IMGUI_COLOR_DRAW 0xFF00FF00
+#define _SG_IMGUI_COLOR_ERR 0xFF8888FF
+
+/*--- C => C++ layer ---------------------------------------------------------*/
+#if defined(__cplusplus)
+#define IMVEC2(x,y) ImVec2(x,y)
+#define IMVEC4(x,y,z,w) ImVec4(x,y,z,w)
+_SOKOL_PRIVATE void igText(const char* fmt,...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::TextV(fmt, args);
+    va_end(args);
+}
+_SOKOL_PRIVATE void igSeparator() {
+    return ImGui::Separator();
+}
+_SOKOL_PRIVATE void igSameLine(float offset_from_start_x, float spacing) {
+    return ImGui::SameLine(offset_from_start_x,spacing);
+}
+_SOKOL_PRIVATE void igPushIDInt(int int_id) {
+    return ImGui::PushID(int_id);
+}
+_SOKOL_PRIVATE void igPopID() {
+    return ImGui::PopID();
+}
+_SOKOL_PRIVATE bool igSelectable(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2 size) {
+    return ImGui::Selectable(label,selected,flags,size);
+}
+_SOKOL_PRIVATE bool igSmallButton(const char* label) {
+    return ImGui::SmallButton(label);
+}
+_SOKOL_PRIVATE bool igBeginChild(const char* str_id,const ImVec2 size,bool border,ImGuiWindowFlags flags) {
+    return ImGui::BeginChild(str_id,size,border,flags);
+}
+_SOKOL_PRIVATE void igEndChild() {
+    return ImGui::EndChild();
+}
+_SOKOL_PRIVATE void igPushStyleColorU32(ImGuiCol idx, ImU32 col) {
+    return ImGui::PushStyleColor(idx,col);
+}
+_SOKOL_PRIVATE void igPopStyleColor(int count) {
+    return ImGui::PopStyleColor(count);
+}
+_SOKOL_PRIVATE bool igTreeNodeStrStr(const char* str_id,const char* fmt,...) {
+    va_list args;
+    va_start(args, fmt);
+    bool ret = ImGui::TreeNodeV(str_id,fmt,args);
+    va_end(args);
+    return ret;
+}
+_SOKOL_PRIVATE bool igTreeNodeStr(const char* label) {
+    return ImGui::TreeNode(label);
+}
+_SOKOL_PRIVATE void igTreePop() {
+    return ImGui::TreePop();
+}
+_SOKOL_PRIVATE bool igIsItemHovered(ImGuiHoveredFlags flags) {
+    return ImGui::IsItemHovered(flags);
+}
+_SOKOL_PRIVATE void igSetTooltip(const char* fmt,...) {
+    va_list args;
+    va_start(args, fmt);
+    ImGui::SetTooltipV(fmt,args);
+    va_end(args);
+}
+_SOKOL_PRIVATE bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power) {
+    return ImGui::SliderFloat(label,v,v_min,v_max,format,power);
+}
+_SOKOL_PRIVATE void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col) {
+    return ImGui::Image(user_texture_id,size,uv0,uv1,tint_col,border_col);
+}
+_SOKOL_PRIVATE void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond) {
+    return ImGui::SetNextWindowSize(size,cond);
+}
+_SOKOL_PRIVATE bool igBegin(const char* name,bool* p_open,ImGuiWindowFlags flags) {
+    return ImGui::Begin(name,p_open,flags);
+}
+_SOKOL_PRIVATE void igEnd() {
+    return ImGui::End();
+}
+#else
+#define IMVEC2(x,y) (ImVec2){x,y}
+#endif
 
 /*--- UTILS ------------------------------------------------------------------*/
 _SOKOL_PRIVATE int _sg_imgui_slot_index(uint32_t id) {
@@ -717,9 +804,9 @@ _SOKOL_PRIVATE const char* _sg_imgui_resourcestate_string(sg_resource_state s) {
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_resource_slot(const sg_slot_info* slot) {
-    ImGui::Text("ResId: %08X", slot->res_id);
-    ImGui::Text("CtxId: %08X", slot->ctx_id);
-    ImGui::Text("State: %s", _sg_imgui_resourcestate_string(slot->state));
+    igText("ResId: %08X", slot->res_id);
+    igText("CtxId: %08X", slot->ctx_id);
+    igText("State: %s", _sg_imgui_resourcestate_string(slot->state));
 }
 
 _SOKOL_PRIVATE const char* _sg_imgui_backend_string(sg_backend b) {
@@ -2344,17 +2431,17 @@ _SOKOL_PRIVATE void _sg_imgui_err_bindings_invalid(void* user_data) {
 
 /*--- IMGUI HELPERS ----------------------------------------------------------*/
 _SOKOL_PRIVATE bool _sg_imgui_draw_resid_list_item(uint32_t res_id, const char* label, bool selected) {
-    ImGui::PushID((int)res_id);
+    igPushIDInt((int)res_id);
     bool res;
     if (label[0]) {
-        res = ImGui::Selectable(label, selected);
+        res = igSelectable(label, selected, 0, IMVEC2(0,0));
     }
     else {
         sg_imgui_str_t str;
         _sg_imgui_snprintf(&str, "0x%08X", res_id);
-        res = ImGui::Selectable(str.buf, selected);
+        res = igSelectable(str.buf, selected, 0, IMVEC2(0,0));
     }
-    ImGui::PopID();
+    igPopID();
     return res;
 }
 
@@ -2369,9 +2456,9 @@ _SOKOL_PRIVATE bool _sg_imgui_draw_resid_link(uint32_t res_id, const char* label
         _sg_imgui_snprintf(&str_buf, "0x%08X", res_id);
         str = str_buf.buf;
     }
-    ImGui::PushID((int)res_id);
-    bool res = ImGui::SmallButton(str);
-    ImGui::PopID();
+    igPushIDInt((int)res_id);
+    bool res = igSmallButton(str);
+    igPopID();
     return res;
 }
 
@@ -2418,7 +2505,7 @@ _SOKOL_PRIVATE void _sg_imgui_show_shader(sg_imgui_t* ctx, sg_shader shd) {
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_buffer_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("buffer_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("buffer_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     for (int i = 0; i < ctx->buffers.num_slots; i++) {
         sg_buffer buf = ctx->buffers.slots[i].res_id;
         sg_resource_state state = sg_query_buffer_state(buf);
@@ -2429,11 +2516,11 @@ _SOKOL_PRIVATE void _sg_imgui_draw_buffer_list(sg_imgui_t* ctx) {
             }
         }
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_image_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("image_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("image_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     for (int i = 0; i < ctx->images.num_slots; i++) {
         sg_image img = ctx->images.slots[i].res_id;
         sg_resource_state state = sg_query_image_state(img);
@@ -2444,11 +2531,11 @@ _SOKOL_PRIVATE void _sg_imgui_draw_image_list(sg_imgui_t* ctx) {
             }
         }
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_shader_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("shader_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("shader_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     for (int i = 0; i < ctx->shaders.num_slots; i++) {
         sg_shader shd = ctx->shaders.slots[i].res_id;
         sg_resource_state state = sg_query_shader_state(shd);
@@ -2459,11 +2546,11 @@ _SOKOL_PRIVATE void _sg_imgui_draw_shader_list(sg_imgui_t* ctx) {
             }
         }
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_pipeline_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("pipeline_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("pipeline_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     for (int i = 1; i < ctx->pipelines.num_slots; i++) {
         sg_pipeline pip = ctx->pipelines.slots[i].res_id;
         sg_resource_state state = sg_query_pipeline_state(pip);
@@ -2474,11 +2561,11 @@ _SOKOL_PRIVATE void _sg_imgui_draw_pipeline_list(sg_imgui_t* ctx) {
             }
         }
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_pass_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("pass_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("pass_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     for (int i = 1; i < ctx->passes.num_slots; i++) {
         sg_pass pass = ctx->passes.slots[i].res_id;
         sg_resource_state state = sg_query_pass_state(pass);
@@ -2489,22 +2576,22 @@ _SOKOL_PRIVATE void _sg_imgui_draw_pass_list(sg_imgui_t* ctx) {
             }
         }
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_capture_list(sg_imgui_t* ctx) {
-    ImGui::BeginChild("capture_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+    igBeginChild("capture_list", IMVEC2(_SG_IMGUI_LIST_WIDTH,0), true, 0);
     const uint32_t num_items = _sg_imgui_capture_num_read_items(ctx);
     uint64_t group_stack = 1;   /* bit set: group unfolded, cleared: folded */
     for (uint32_t i = 0; i < num_items; i++) {
         const sg_imgui_capture_item_t* item = _sg_imgui_capture_read_item_at(ctx, i);
         sg_imgui_str_t item_string = _sg_imgui_capture_item_string(ctx, i, item);
-        ImGui::PushStyleColor(ImGuiCol_Text, item->color);
+        igPushStyleColorU32(ImGuiCol_Text, item->color);
         if (item->cmd == SG_IMGUI_CMD_PUSH_DEBUG_GROUP) {
             if (group_stack & 1) {
                 group_stack <<= 1;
                 const char* group_name = item->args.push_debug_group.name.buf;
-                if (ImGui::TreeNode(group_name, "Group: %s", group_name)) {
+                if (igTreeNodeStrStr(group_name, "Group: %s", group_name)) {
                     group_stack |= 1;
                 }
             }
@@ -2514,51 +2601,51 @@ _SOKOL_PRIVATE void _sg_imgui_draw_capture_list(sg_imgui_t* ctx) {
         }
         else if (item->cmd == SG_IMGUI_CMD_POP_DEBUG_GROUP) {
             if (group_stack & 1) {
-                ImGui::TreePop();
+                igTreePop();
             }
             group_stack >>= 1;
         }
         else if (group_stack & 1) {
-            ImGui::PushID(i);
-            if (ImGui::Selectable(item_string.buf, ctx->capture.sel_item == i)) {
+            igPushIDInt(i);
+            if (igSelectable(item_string.buf, ctx->capture.sel_item == i, 0, IMVEC2(0,0))) {
                 ctx->capture.sel_item = i;
             }
-            if (ImGui::IsItemHovered()) {
-                ImGui::SetTooltip("%s", item_string.buf);
+            if (igIsItemHovered(0)) {
+                igSetTooltip("%s", item_string.buf);
             }
-            ImGui::PopID();
+            igPopID();
         }
-        ImGui::PopStyleColor();
+        igPopStyleColor(1);
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_buffer_panel(sg_imgui_t* ctx, sg_buffer buf) {
     if (buf.id != SG_INVALID_ID) {
-        ImGui::BeginChild("buffer", ImVec2(0,0), false);
+        igBeginChild("buffer", IMVEC2(0,0), false, 0);
         sg_buffer_info info = sg_query_buffer_info(buf);
         if (info.slot.state == SG_RESOURCESTATE_VALID) {
             const sg_imgui_buffer_t* buf_ui = &ctx->buffers.slots[_sg_imgui_slot_index(buf.id)];
-            ImGui::Text("Label: %s", buf_ui->label.buf[0] ? buf_ui->label.buf : "---");
+            igText("Label: %s", buf_ui->label.buf[0] ? buf_ui->label.buf : "---");
             _sg_imgui_draw_resource_slot(&info.slot);
-            ImGui::Separator();
-            ImGui::Text("Type:  %s", _sg_imgui_buffertype_string(buf_ui->desc.type));
-            ImGui::Text("Usage: %s", _sg_imgui_usage_string(buf_ui->desc.usage));
-            ImGui::Text("Size:  %d", buf_ui->desc.size);
+            igSeparator();
+            igText("Type:  %s", _sg_imgui_buffertype_string(buf_ui->desc.type));
+            igText("Usage: %s", _sg_imgui_usage_string(buf_ui->desc.usage));
+            igText("Size:  %d", buf_ui->desc.size);
             if (buf_ui->desc.usage != SG_USAGE_IMMUTABLE) {
-                ImGui::Separator();
-                ImGui::Text("Num Slots:     %d", info.num_slots);
-                ImGui::Text("Active Slot:   %d", info.active_slot);
-                ImGui::Text("Update Frame Index: %d", info.update_frame_index);
-                ImGui::Text("Append Frame Index: %d", info.append_frame_index);
-                ImGui::Text("Append Pos:         %d", info.append_pos);
-                ImGui::Text("Append Overflow:    %s", info.append_overflow ? "YES":"NO");
+                igSeparator();
+                igText("Num Slots:     %d", info.num_slots);
+                igText("Active Slot:   %d", info.active_slot);
+                igText("Update Frame Index: %d", info.update_frame_index);
+                igText("Append Frame Index: %d", info.append_frame_index);
+                igText("Append Pos:         %d", info.append_pos);
+                igText("Append Overflow:    %s", info.append_overflow ? "YES":"NO");
             }
         }
         else {
-            ImGui::Text("Buffer 0x%08X not valid.", buf.id);
+            igText("Buffer 0x%08X not valid.", buf.id);
         }
-        ImGui::EndChild();
+        igEndChild();
     }
 }
 
@@ -2570,59 +2657,59 @@ _SOKOL_PRIVATE void _sg_imgui_draw_embedded_image(sg_imgui_t* ctx, sg_image img,
     if (sg_query_image_state(img) == SG_RESOURCESTATE_VALID) {
         sg_imgui_image_t* img_ui = &ctx->images.slots[_sg_imgui_slot_index(img.id)];
         if (_sg_imgui_image_renderable(ctx, img_ui->desc.type, img_ui->desc.pixel_format)) {
-            ImGui::PushID((int)img.id);
-            ImGui::SliderFloat("Scale", scale, 0.125f, 8.0f, "%.3f", 2.0f);
+            igPushIDInt((int)img.id);
+            igSliderFloat("Scale", scale, 0.125f, 8.0f, "%.3f", 2.0f);
             float w = (float)img_ui->desc.width * (*scale);
             float h = (float)img_ui->desc.height * (*scale);
-            ImGui::Image((ImTextureID)(intptr_t)img.id, ImVec2(w, h));
-            ImGui::PopID();
+            igImage((ImTextureID)(intptr_t)img.id, IMVEC2(w, h), IMVEC2(0,0), IMVEC2(1,1), IMVEC4(1,1,1,1), IMVEC4(0,0,0,0));
+            igPopID();
         }
         else {
-            ImGui::Text("Image not renderable.");
+            igText("Image not renderable.");
         }
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_image_panel(sg_imgui_t* ctx, sg_image img) {
     if (img.id != SG_INVALID_ID) {
-        ImGui::BeginChild("image", ImVec2(0,0), false);
+        igBeginChild("image", IMVEC2(0,0), false, 0);
         sg_image_info info = sg_query_image_info(img);
         if (info.slot.state == SG_RESOURCESTATE_VALID) {
             sg_imgui_image_t* img_ui = &ctx->images.slots[_sg_imgui_slot_index(img.id)];
             const sg_image_desc* desc = &img_ui->desc;
-            ImGui::Text("Label: %s", img_ui->label.buf[0] ? img_ui->label.buf : "---");
+            igText("Label: %s", img_ui->label.buf[0] ? img_ui->label.buf : "---");
             _sg_imgui_draw_resource_slot(&info.slot);
-            ImGui::Separator();
+            igSeparator();
             _sg_imgui_draw_embedded_image(ctx, img, &img_ui->ui_scale);
-            ImGui::Separator();
-            ImGui::Text("Type:              %s", _sg_imgui_imagetype_string(desc->type));
-            ImGui::Text("Usage:             %s", _sg_imgui_usage_string(desc->usage));
-            ImGui::Text("Render Target:     %s", desc->render_target ? "YES":"NO");
-            ImGui::Text("Width:             %d", desc->width);
-            ImGui::Text("Height:            %d", desc->height);
-            ImGui::Text("Depth:             %d", desc->depth);
-            ImGui::Text("Num Mipmaps:       %d", desc->num_mipmaps);
-            ImGui::Text("Pixel Format:      %s", _sg_imgui_pixelformat_string(desc->pixel_format));
-            ImGui::Text("Sample Count:      %d", desc->sample_count);
-            ImGui::Text("Min Filter:        %s", _sg_imgui_filter_string(desc->min_filter));
-            ImGui::Text("Mag Filter:        %s", _sg_imgui_filter_string(desc->mag_filter));
-            ImGui::Text("Wrap U:            %s", _sg_imgui_wrap_string(desc->wrap_u));
-            ImGui::Text("Wrap V:            %s", _sg_imgui_wrap_string(desc->wrap_v));
-            ImGui::Text("Wrap W:            %s", _sg_imgui_wrap_string(desc->wrap_w));
-            ImGui::Text("Max Anisotropy:    %d", desc->max_anisotropy);
-            ImGui::Text("Min LOD:           %.3f", desc->min_lod);
-            ImGui::Text("Max LOD:           %.3f", desc->max_lod);
+            igSeparator();
+            igText("Type:              %s", _sg_imgui_imagetype_string(desc->type));
+            igText("Usage:             %s", _sg_imgui_usage_string(desc->usage));
+            igText("Render Target:     %s", desc->render_target ? "YES":"NO");
+            igText("Width:             %d", desc->width);
+            igText("Height:            %d", desc->height);
+            igText("Depth:             %d", desc->depth);
+            igText("Num Mipmaps:       %d", desc->num_mipmaps);
+            igText("Pixel Format:      %s", _sg_imgui_pixelformat_string(desc->pixel_format));
+            igText("Sample Count:      %d", desc->sample_count);
+            igText("Min Filter:        %s", _sg_imgui_filter_string(desc->min_filter));
+            igText("Mag Filter:        %s", _sg_imgui_filter_string(desc->mag_filter));
+            igText("Wrap U:            %s", _sg_imgui_wrap_string(desc->wrap_u));
+            igText("Wrap V:            %s", _sg_imgui_wrap_string(desc->wrap_v));
+            igText("Wrap W:            %s", _sg_imgui_wrap_string(desc->wrap_w));
+            igText("Max Anisotropy:    %d", desc->max_anisotropy);
+            igText("Min LOD:           %.3f", desc->min_lod);
+            igText("Max LOD:           %.3f", desc->max_lod);
             if (desc->usage != SG_USAGE_IMMUTABLE) {
-                ImGui::Separator();
-                ImGui::Text("Num Slots:     %d", info.num_slots);
-                ImGui::Text("Active Slot:   %d", info.active_slot);
-                ImGui::Text("Update Frame Index: %d", info.upd_frame_index);
+                igSeparator();
+                igText("Num Slots:     %d", info.num_slots);
+                igText("Active Slot:   %d", info.active_slot);
+                igText("Update Frame Index: %d", info.upd_frame_index);
             }
         }
         else {
-            ImGui::Text("Image 0x%08X not valid.", img.id);
+            igText("Image 0x%08X not valid.", img.id);
         }
-        ImGui::EndChild();
+        igEndChild();
     }
 }
 
@@ -2648,244 +2735,244 @@ _SOKOL_PRIVATE void _sg_imgui_draw_shader_stage(sg_imgui_t* ctx, const sg_shader
         }
     }
     if (num_valid_ubs > 0) {
-        if (ImGui::TreeNode("Uniform Blocks")) {
+        if (igTreeNodeStr("Uniform Blocks")) {
             for (int i = 0; i < num_valid_ubs; i++) {
-                ImGui::Text("#%d:", i);
+                igText("#%d:", i);
                 const sg_shader_uniform_block_desc* ub = &stage->uniform_blocks[i];
                 for (int j = 0; j < SG_MAX_UB_MEMBERS; j++) {
                     const sg_shader_uniform_desc* u = &ub->uniforms[j];
                     if (SG_UNIFORMTYPE_INVALID != u->type) {
                         if (u->array_count == 0) {
-                            ImGui::Text("  %s %s", _sg_imgui_uniformtype_string(u->type), u->name ? u->name : "");
+                            igText("  %s %s", _sg_imgui_uniformtype_string(u->type), u->name ? u->name : "");
                         }
                         else {
-                            ImGui::Text("  %s[%d] %s", _sg_imgui_uniformtype_string(u->type), u->array_count, u->name ? u->name : "");
+                            igText("  %s[%d] %s", _sg_imgui_uniformtype_string(u->type), u->array_count, u->name ? u->name : "");
                         }
                     }
                 }
             }
-            ImGui::TreePop();
+            igTreePop();
         }
     }
     if (num_valid_images > 0) {
-        if (ImGui::TreeNode("Images")) {
+        if (igTreeNodeStr("Images")) {
             for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
                 const sg_shader_image_desc* sid = &stage->images[i];
                 if (sid->type != _SG_IMAGETYPE_DEFAULT) {
-                    ImGui::Text("%s %s", _sg_imgui_imagetype_string(sid->type), sid->name ? sid->name : "");
+                    igText("%s %s", _sg_imgui_imagetype_string(sid->type), sid->name ? sid->name : "");
                 }
                 else {
                     break;
                 }
             }
-            ImGui::TreePop();
+            igTreePop();
         }
     }
     if (stage->entry) {
-        ImGui::Text("Entry: %s", stage->entry);
+        igText("Entry: %s", stage->entry);
     }
     if (stage->source) {
-        if (ImGui::TreeNode("Source")) {
-            ImGui::Text("%s", stage->source);
-            ImGui::TreePop();
+        if (igTreeNodeStr("Source")) {
+            igText("%s", stage->source);
+            igTreePop();
         }
     }
     else if (stage->byte_code) {
-        if (ImGui::TreeNode("Byte Code")) {
-            ImGui::Text("Byte-code display currently not supported.");
-            ImGui::TreePop();
+        if (igTreeNodeStr("Byte Code")) {
+            igText("Byte-code display currently not supported.");
+            igTreePop();
         }
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_shader_panel(sg_imgui_t* ctx, sg_shader shd) {
     if (shd.id != SG_INVALID_ID) {
-        ImGui::BeginChild("shader", ImVec2(0,0), false, ImGuiWindowFlags_HorizontalScrollbar);
+        igBeginChild("shader", IMVEC2(0,0), false, ImGuiWindowFlags_HorizontalScrollbar);
         sg_shader_info info = sg_query_shader_info(shd);
         if (info.slot.state == SG_RESOURCESTATE_VALID) {
             const sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_imgui_slot_index(shd.id)];
-            ImGui::Text("Label: %s", shd_ui->label.buf[0] ? shd_ui->label.buf : "---");
+            igText("Label: %s", shd_ui->label.buf[0] ? shd_ui->label.buf : "---");
             _sg_imgui_draw_resource_slot(&info.slot);
-            ImGui::Separator();
-            if (ImGui::TreeNode("Attrs")) {
+            igSeparator();
+            if (igTreeNodeStr("Attrs")) {
                 for (int i = 0; i < SG_MAX_VERTEX_ATTRIBUTES; i++) {
                     const sg_shader_attr_desc* a_desc = &shd_ui->desc.attrs[i];
                     if (a_desc->name || a_desc->sem_index) {
-                        ImGui::Text("#%d:", i);
-                        ImGui::Text("  Name:         %s", a_desc->name ? a_desc->name : "---");
-                        ImGui::Text("  Sem Name:     %s", a_desc->sem_name ? a_desc->sem_name : "---");
-                        ImGui::Text("  Sem Index:    %d", a_desc->sem_index);
+                        igText("#%d:", i);
+                        igText("  Name:         %s", a_desc->name ? a_desc->name : "---");
+                        igText("  Sem Name:     %s", a_desc->sem_name ? a_desc->sem_name : "---");
+                        igText("  Sem Index:    %d", a_desc->sem_index);
                     }
                 }
-                ImGui::TreePop();
+                igTreePop();
             }
-            if (ImGui::TreeNode("Vertex Shader Stage")) {
+            if (igTreeNodeStr("Vertex Shader Stage")) {
                 _sg_imgui_draw_shader_stage(ctx, &shd_ui->desc.vs);
-                ImGui::TreePop();
+                igTreePop();
             }
-            if (ImGui::TreeNode("Fragment Shader Stage")) {
+            if (igTreeNodeStr("Fragment Shader Stage")) {
                 _sg_imgui_draw_shader_stage(ctx, &shd_ui->desc.fs);
-                ImGui::TreePop();
+                igTreePop();
             }
         }
         else {
-            ImGui::Text("Shader 0x%08X not valid!", shd.id);
+            igText("Shader 0x%08X not valid!", shd.id);
         }
-        ImGui::EndChild();
+        igEndChild();
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_vertex_layout(const sg_layout_desc* layout) {
-    if (ImGui::TreeNode("Buffers")) {
+    if (igTreeNodeStr("Buffers")) {
         for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++) {
             const sg_buffer_layout_desc* l_desc = &layout->buffers[i];
             if (l_desc->stride > 0) {
-                ImGui::Text("#%d:", i);
-                ImGui::Text("  Stride:    %d", l_desc->stride);
-                ImGui::Text("  Step Func: %s", _sg_imgui_vertexstep_string(l_desc->step_func));
-                ImGui::Text("  Step Rate: %d", l_desc->step_rate);
+                igText("#%d:", i);
+                igText("  Stride:    %d", l_desc->stride);
+                igText("  Step Func: %s", _sg_imgui_vertexstep_string(l_desc->step_func));
+                igText("  Step Rate: %d", l_desc->step_rate);
             }
         }
-        ImGui::TreePop();
+        igTreePop();
     }
-    if (ImGui::TreeNode("Attrs")) {
+    if (igTreeNodeStr("Attrs")) {
         for (int i = 0; i < SG_MAX_VERTEX_ATTRIBUTES; i++) {
             const sg_vertex_attr_desc* a_desc = &layout->attrs[i];
             if (a_desc->format != SG_VERTEXFORMAT_INVALID) {
-                ImGui::Text("#%d:", i);
-                ImGui::Text("  Format:       %s", _sg_imgui_vertexformat_string(a_desc->format));
-                ImGui::Text("  Offset:       %d", a_desc->offset);
-                ImGui::Text("  Buffer Index: %d", a_desc->buffer_index);
+                igText("#%d:", i);
+                igText("  Format:       %s", _sg_imgui_vertexformat_string(a_desc->format));
+                igText("  Offset:       %d", a_desc->offset);
+                igText("  Buffer Index: %d", a_desc->buffer_index);
             }
         }
-        ImGui::TreePop();
+        igTreePop();
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_stencil_state(const sg_stencil_state* ss) {
-    ImGui::Text("Fail Op:       %s", _sg_imgui_stencilop_string(ss->fail_op));
-    ImGui::Text("Depth Fail Op: %s", _sg_imgui_stencilop_string(ss->depth_fail_op));
-    ImGui::Text("Pass Op:       %s", _sg_imgui_stencilop_string(ss->pass_op));
-    ImGui::Text("Compare Func:  %s", _sg_imgui_comparefunc_string(ss->compare_func));
+    igText("Fail Op:       %s", _sg_imgui_stencilop_string(ss->fail_op));
+    igText("Depth Fail Op: %s", _sg_imgui_stencilop_string(ss->depth_fail_op));
+    igText("Pass Op:       %s", _sg_imgui_stencilop_string(ss->pass_op));
+    igText("Compare Func:  %s", _sg_imgui_comparefunc_string(ss->compare_func));
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_depth_stencil_state(const sg_depth_stencil_state* dss) {
-    ImGui::Text("Depth Compare Func:  %s", _sg_imgui_comparefunc_string(dss->depth_compare_func));
-    ImGui::Text("Depth Write Enabled: %s", dss->depth_write_enabled ? "YES":"NO");
-    ImGui::Text("Stencil Enabled:     %s", dss->stencil_enabled ? "YES":"NO");
-    ImGui::Text("Stencil Read Mask:   0x%02X", dss->stencil_read_mask);
-    ImGui::Text("Stencil Write Mask:  0x%02X", dss->stencil_write_mask);
-    ImGui::Text("Stencil Ref:         0x%02X", dss->stencil_ref);
-    if (ImGui::TreeNode("Stencil Front")) {
+    igText("Depth Compare Func:  %s", _sg_imgui_comparefunc_string(dss->depth_compare_func));
+    igText("Depth Write Enabled: %s", dss->depth_write_enabled ? "YES":"NO");
+    igText("Stencil Enabled:     %s", dss->stencil_enabled ? "YES":"NO");
+    igText("Stencil Read Mask:   0x%02X", dss->stencil_read_mask);
+    igText("Stencil Write Mask:  0x%02X", dss->stencil_write_mask);
+    igText("Stencil Ref:         0x%02X", dss->stencil_ref);
+    if (igTreeNodeStr("Stencil Front")) {
         _sg_imgui_draw_stencil_state(&dss->stencil_front);
-        ImGui::TreePop();
+        igTreePop();
     }
-    if (ImGui::TreeNode("Stencil Back")) {
+    if (igTreeNodeStr("Stencil Back")) {
         _sg_imgui_draw_stencil_state(&dss->stencil_back);
-        ImGui::TreePop();
+        igTreePop();
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_blend_state(const sg_blend_state* bs) {
-    ImGui::Text("Blend Enabled:    %s", bs->enabled ? "YES":"NO");
-    ImGui::Text("Src Factor RGB:   %s", _sg_imgui_blendfactor_string(bs->src_factor_rgb));
-    ImGui::Text("Dst Factor RGB:   %s", _sg_imgui_blendfactor_string(bs->dst_factor_rgb));
-    ImGui::Text("Op RGB:           %s", _sg_imgui_blendop_string(bs->op_rgb));
-    ImGui::Text("Src Factor Alpha: %s", _sg_imgui_blendfactor_string(bs->src_factor_alpha));
-    ImGui::Text("Dst Factor Alpha: %s", _sg_imgui_blendfactor_string(bs->dst_factor_alpha));
-    ImGui::Text("Op Alpha:         %s", _sg_imgui_blendop_string(bs->op_alpha));
-    ImGui::Text("Color Write Mask: %s", _sg_imgui_colormask_string(bs->color_write_mask));
-    ImGui::Text("Attachment Count: %d", bs->color_attachment_count);
-    ImGui::Text("Color Format:     %s", _sg_imgui_pixelformat_string(bs->color_format));
-    ImGui::Text("Depth Format:     %s", _sg_imgui_pixelformat_string(bs->depth_format));
-    ImGui::Text("Blend Color:      %.3f %.3f %.3f %.3f", bs->blend_color[0], bs->blend_color[1], bs->blend_color[2], bs->blend_color[3]);
+    igText("Blend Enabled:    %s", bs->enabled ? "YES":"NO");
+    igText("Src Factor RGB:   %s", _sg_imgui_blendfactor_string(bs->src_factor_rgb));
+    igText("Dst Factor RGB:   %s", _sg_imgui_blendfactor_string(bs->dst_factor_rgb));
+    igText("Op RGB:           %s", _sg_imgui_blendop_string(bs->op_rgb));
+    igText("Src Factor Alpha: %s", _sg_imgui_blendfactor_string(bs->src_factor_alpha));
+    igText("Dst Factor Alpha: %s", _sg_imgui_blendfactor_string(bs->dst_factor_alpha));
+    igText("Op Alpha:         %s", _sg_imgui_blendop_string(bs->op_alpha));
+    igText("Color Write Mask: %s", _sg_imgui_colormask_string(bs->color_write_mask));
+    igText("Attachment Count: %d", bs->color_attachment_count);
+    igText("Color Format:     %s", _sg_imgui_pixelformat_string(bs->color_format));
+    igText("Depth Format:     %s", _sg_imgui_pixelformat_string(bs->depth_format));
+    igText("Blend Color:      %.3f %.3f %.3f %.3f", bs->blend_color[0], bs->blend_color[1], bs->blend_color[2], bs->blend_color[3]);
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_rasterizer_state(const sg_rasterizer_state* rs) {
-    ImGui::Text("Alpha to Coverage: %s", rs->alpha_to_coverage_enabled ? "YES":"NO");
-    ImGui::Text("Cull Mode:         %s", _sg_imgui_cullmode_string(rs->cull_mode));
-    ImGui::Text("Face Winding:      %s", _sg_imgui_facewinding_string(rs->face_winding));
-    ImGui::Text("Sample Count:      %d", rs->sample_count);
-    ImGui::Text("Depth Bias:        %f", rs->depth_bias);
-    ImGui::Text("Depth Bias Slope:  %f", rs->depth_bias_slope_scale);
-    ImGui::Text("Depth Bias Clamp:  %f", rs->depth_bias_clamp);
+    igText("Alpha to Coverage: %s", rs->alpha_to_coverage_enabled ? "YES":"NO");
+    igText("Cull Mode:         %s", _sg_imgui_cullmode_string(rs->cull_mode));
+    igText("Face Winding:      %s", _sg_imgui_facewinding_string(rs->face_winding));
+    igText("Sample Count:      %d", rs->sample_count);
+    igText("Depth Bias:        %f", rs->depth_bias);
+    igText("Depth Bias Slope:  %f", rs->depth_bias_slope_scale);
+    igText("Depth Bias Clamp:  %f", rs->depth_bias_clamp);
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_pipeline_panel(sg_imgui_t* ctx, sg_pipeline pip) {
     if (pip.id != SG_INVALID_ID) {
-        ImGui::BeginChild("pipeline", ImVec2(0,0), false);
+        igBeginChild("pipeline", IMVEC2(0,0), false, 0);
         sg_pipeline_info info = sg_query_pipeline_info(pip);
         if (info.slot.state == SG_RESOURCESTATE_VALID) {
             const sg_imgui_pipeline_t* pip_ui = &ctx->pipelines.slots[_sg_imgui_slot_index(pip.id)];
-            ImGui::Text("Label: %s", pip_ui->label.buf[0] ? pip_ui->label.buf : "---");
+            igText("Label: %s", pip_ui->label.buf[0] ? pip_ui->label.buf : "---");
             _sg_imgui_draw_resource_slot(&info.slot);
-            ImGui::Separator();
-            ImGui::Text("Shader:    "); ImGui::SameLine();
+            igSeparator();
+            igText("Shader:    "); igSameLine(0,-1);
             if (_sg_imgui_draw_shader_link(ctx, pip_ui->desc.shader)) {
                 _sg_imgui_show_shader(ctx, pip_ui->desc.shader);
             }
-            ImGui::Text("Prim Type:  %s", _sg_imgui_primitivetype_string(pip_ui->desc.primitive_type));
-            ImGui::Text("Index Type: %s", _sg_imgui_indextype_string(pip_ui->desc.index_type));
-            if (ImGui::TreeNode("Vertex Layout")) {
+            igText("Prim Type:  %s", _sg_imgui_primitivetype_string(pip_ui->desc.primitive_type));
+            igText("Index Type: %s", _sg_imgui_indextype_string(pip_ui->desc.index_type));
+            if (igTreeNodeStr("Vertex Layout")) {
                 _sg_imgui_draw_vertex_layout(&pip_ui->desc.layout);
-                ImGui::TreePop();
+                igTreePop();
             }
-            if (ImGui::TreeNode("Depth Stencil State")) {
+            if (igTreeNodeStr("Depth Stencil State")) {
                 _sg_imgui_draw_depth_stencil_state(&pip_ui->desc.depth_stencil);
-                ImGui::TreePop();
+                igTreePop();
             }
-            if (ImGui::TreeNode("Blend State")) {
+            if (igTreeNodeStr("Blend State")) {
                 _sg_imgui_draw_blend_state(&pip_ui->desc.blend);
-                ImGui::TreePop();
+                igTreePop();
             }
-            if (ImGui::TreeNode("Rasterizer State")) {
+            if (igTreeNodeStr("Rasterizer State")) {
                 _sg_imgui_draw_rasterizer_state(&pip_ui->desc.rasterizer);
-                ImGui::TreePop();
+                igTreePop();
             }
         }
         else {
-            ImGui::Text("Pipeline 0x%08X not valid.", pip.id);
+            igText("Pipeline 0x%08X not valid.", pip.id);
         }
-        ImGui::EndChild();
+        igEndChild();
     }
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_attachment(sg_imgui_t* ctx, const sg_attachment_desc* att, float* img_scale) {
-    ImGui::Text("  Image: "); ImGui::SameLine();
+    igText("  Image: "); igSameLine(0,-1);
     if (_sg_imgui_draw_image_link(ctx, att->image)) {
         _sg_imgui_show_image(ctx, att->image);
     }
-    ImGui::Text("  Mip Level: %d", att->mip_level);
-    ImGui::Text("  Face/Layer/Slice: %d", att->layer);
+    igText("  Mip Level: %d", att->mip_level);
+    igText("  Face/Layer/Slice: %d", att->layer);
     _sg_imgui_draw_embedded_image(ctx, att->image, img_scale);
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_pass_panel(sg_imgui_t* ctx, sg_pass pass) {
     if (pass.id != SG_INVALID_ID) {
-        ImGui::BeginChild("pass", ImVec2(0,0), false);
+        igBeginChild("pass", IMVEC2(0,0), false, 0);
         sg_pass_info info = sg_query_pass_info(pass);
         if (info.slot.state == SG_RESOURCESTATE_VALID) {
             sg_imgui_pass_t* pass_ui = &ctx->passes.slots[_sg_imgui_slot_index(pass.id)];
-            ImGui::Text("Label: %s", pass_ui->label.buf[0] ? pass_ui->label.buf : "---");
+            igText("Label: %s", pass_ui->label.buf[0] ? pass_ui->label.buf : "---");
             _sg_imgui_draw_resource_slot(&info.slot);
             for (int i = 0; i < SG_MAX_COLOR_ATTACHMENTS; i++) {
                 if (pass_ui->desc.color_attachments[i].image.id == SG_INVALID_ID) {
                     break;
                 }
-                ImGui::Separator();
-                ImGui::Text("Color Attachment #%d:", i);
+                igSeparator();
+                igText("Color Attachment #%d:", i);
                 _sg_imgui_draw_attachment(ctx, &pass_ui->desc.color_attachments[i], &pass_ui->color_image_scale[i]);
             }
             if (pass_ui->desc.depth_stencil_attachment.image.id != SG_INVALID_ID) {
-                ImGui::Separator();
-                ImGui::Text("Depth-Stencil Attachemnt:");
+                igSeparator();
+                igText("Depth-Stencil Attachemnt:");
                 _sg_imgui_draw_attachment(ctx, &pass_ui->desc.depth_stencil_attachment, &pass_ui->ds_image_scale);
             }
         }
         else {
-            ImGui::Text("Pass 0x%08X not valid.", pass.id);
+            igText("Pass 0x%08X not valid.", pass.id);
         }
-        ImGui::EndChild();
+        igEndChild();
     }
 }
 
@@ -2893,13 +2980,13 @@ _SOKOL_PRIVATE void _sg_imgui_draw_bindings_panel(sg_imgui_t* ctx, const sg_bind
     for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++) {
         sg_buffer buf = bnd->vertex_buffers[i];
         if (buf.id != SG_INVALID_ID) {
-            ImGui::Separator();
-            ImGui::Text("Vertex Buffer Slot #%d:", i);
-            ImGui::Text("  Buffer: "); ImGui::SameLine();
+            igSeparator();
+            igText("Vertex Buffer Slot #%d:", i);
+            igText("  Buffer: "); igSameLine(0,-1);
             if (_sg_imgui_draw_buffer_link(ctx, buf)) {
                 _sg_imgui_show_buffer(ctx, buf);
             }
-            ImGui::Text("  Offset: %d", bnd->vertex_buffer_offsets[i]);
+            igText("  Offset: %d", bnd->vertex_buffer_offsets[i]);
         }
         else {
             break;
@@ -2908,21 +2995,21 @@ _SOKOL_PRIVATE void _sg_imgui_draw_bindings_panel(sg_imgui_t* ctx, const sg_bind
     if (bnd->index_buffer.id != SG_INVALID_ID) {
         sg_buffer buf = bnd->index_buffer;
         if (buf.id != SG_INVALID_ID) {
-            ImGui::Separator();
-            ImGui::Text("Index Buffer Slot:");
-            ImGui::Text("  Buffer: "); ImGui::SameLine();
+            igSeparator();
+            igText("Index Buffer Slot:");
+            igText("  Buffer: "); igSameLine(0,-1);
             if (_sg_imgui_draw_buffer_link(ctx, buf)) {
                 _sg_imgui_show_buffer(ctx, buf);
             }
-            ImGui::Text("  Offset: %d", bnd->index_buffer_offset);
+            igText("  Offset: %d", bnd->index_buffer_offset);
         }
     }
     for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
         sg_image img = bnd->vs_images[i];
         if (img.id != SG_INVALID_ID) {
-            ImGui::Separator();
-            ImGui::Text("Vertex Stage Image Slot #%d:", i);
-            ImGui::Text("  Image: "); ImGui::SameLine();
+            igSeparator();
+            igText("Vertex Stage Image Slot #%d:", i);
+            igText("  Image: "); igSameLine(0,-1);
             if (_sg_imgui_draw_image_link(ctx, img)) {
                 _sg_imgui_show_image(ctx, img);
             }
@@ -2934,9 +3021,9 @@ _SOKOL_PRIVATE void _sg_imgui_draw_bindings_panel(sg_imgui_t* ctx, const sg_bind
     for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
         sg_image img = bnd->fs_images[i];
         if (img.id != SG_INVALID_ID) {
-            ImGui::Separator();
-            ImGui::Text("Fragment Stage Image Slot #%d:", i);
-            ImGui::Text("  Image: "); ImGui::SameLine();
+            igSeparator();
+            igText("Fragment Stage Image Slot #%d:", i);
+            igText("  Image: "); igSameLine(0,-1);
             if (_sg_imgui_draw_image_link(ctx, img)) {
                 _sg_imgui_show_image(ctx, img);
             }
@@ -2951,12 +3038,12 @@ _SOKOL_PRIVATE void _sg_imgui_draw_uniforms_panel(sg_imgui_t* ctx, const sg_imgu
         is available, otherwise just render a generic hexdump
     */
    if (sg_query_pipeline_state(args->pipeline) != SG_RESOURCESTATE_VALID) {
-        ImGui::Text("Pipeline object not valid!");
+        igText("Pipeline object not valid!");
         return;
    }
     sg_imgui_pipeline_t* pip_ui = &ctx->pipelines.slots[_sg_imgui_slot_index(args->pipeline.id)];
     if (sg_query_shader_state(pip_ui->desc.shader) != SG_RESOURCESTATE_VALID) {
-        ImGui::Text("Shader object not valid!");
+        igText("Shader object not valid!");
         return;
     }
     sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_imgui_slot_index(pip_ui->desc.shader.id)];
@@ -2981,37 +3068,37 @@ _SOKOL_PRIVATE void _sg_imgui_draw_uniforms_panel(sg_imgui_t* ctx, const sg_imgu
             }
             int num_items = (ud->array_count > 1) ? ud->array_count : 1;
             if (num_items > 1) {
-                ImGui::Text("%d: %s %s[%d] =", i, _sg_imgui_uniformtype_string(ud->type), ud->name?ud->name:"", ud->array_count);
+                igText("%d: %s %s[%d] =", i, _sg_imgui_uniformtype_string(ud->type), ud->name?ud->name:"", ud->array_count);
             }
             else {
-                ImGui::Text("%d: %s %s =", i, _sg_imgui_uniformtype_string(ud->type), ud->name?ud->name:"");
+                igText("%d: %s %s =", i, _sg_imgui_uniformtype_string(ud->type), ud->name?ud->name:"");
             }
             for (int i = 0; i < num_items; i++) {
                 switch (ud->type) {
                     case SG_UNIFORMTYPE_FLOAT:
-                        ImGui::Text("    %.3f", *uptrf);
+                        igText("    %.3f", *uptrf);
                         break;
                     case SG_UNIFORMTYPE_FLOAT2:
-                        ImGui::Text("    %.3f, %.3f", uptrf[0], uptrf[1]);
+                        igText("    %.3f, %.3f", uptrf[0], uptrf[1]);
                         break;
                     case SG_UNIFORMTYPE_FLOAT3:
-                        ImGui::Text("    %.3f, %.3f, %.3f", uptrf[0], uptrf[1], uptrf[2]);
+                        igText("    %.3f, %.3f, %.3f", uptrf[0], uptrf[1], uptrf[2]);
                         break;
                     case SG_UNIFORMTYPE_FLOAT4:
-                        ImGui::Text("    %.3f, %.3f, %.3f, %.3f", uptrf[0], uptrf[1], uptrf[2], uptrf[3]);
+                        igText("    %.3f, %.3f, %.3f, %.3f", uptrf[0], uptrf[1], uptrf[2], uptrf[3]);
                         break;
                     case SG_UNIFORMTYPE_MAT4:
-                        ImGui::Text("    %.3f, %.3f, %.3f, %.3f\n"
-                                    "    %.3f, %.3f, %.3f, %.3f\n"
-                                    "    %.3f, %.3f, %.3f, %.3f\n"
-                                    "    %.3f, %.3f, %.3f, %.3f",
+                        igText("    %.3f, %.3f, %.3f, %.3f\n"
+                               "    %.3f, %.3f, %.3f, %.3f\n"
+                               "    %.3f, %.3f, %.3f, %.3f\n"
+                               "    %.3f, %.3f, %.3f, %.3f",
                             uptrf[0],  uptrf[1],  uptrf[2],  uptrf[3],
                             uptrf[4],  uptrf[5],  uptrf[6],  uptrf[7],
                             uptrf[8],  uptrf[9],  uptrf[10], uptrf[11],
                             uptrf[12], uptrf[13], uptrf[14], uptrf[15]);
                         break;
                     default:
-                        ImGui::Text("???");
+                        igText("???");
                         break;
                 }
                 uptrf += _sg_imgui_uniform_size(ud->type, 1) / sizeof(float);
@@ -3021,9 +3108,9 @@ _SOKOL_PRIVATE void _sg_imgui_draw_uniforms_panel(sg_imgui_t* ctx, const sg_imgu
     else {
         const uint32_t num_floats = ub_desc->size / sizeof(float);
         for (uint32_t i = 0; i < num_floats; i++) {
-            ImGui::Text("%.3f, ", uptrf[i]);
+            igText("%.3f, ", uptrf[i]);
             if (((i + 1) % 4) != 0) {
-                ImGui::SameLine();
+                igSameLine(0,-1);
             }
         }
     }
@@ -3045,15 +3132,15 @@ _SOKOL_PRIVATE void _sg_imgui_draw_passaction_panel(sg_imgui_t* ctx, sg_pass pas
         }
     }
 
-    ImGui::Text("Pass Action: ");
+    igText("Pass Action: ");
     for (int i = 0; i < num_color_atts; i++) {
         const sg_color_attachment_action* c_att = &action->colors[i];
-        ImGui::Text("  Color Attachment %d:", i);
+        igText("  Color Attachment %d:", i);
         switch (c_att->action) {
-            case SG_ACTION_LOAD: ImGui::Text("    SG_ACTION_LOAD"); break;
-            case SG_ACTION_DONTCARE: ImGui::Text("    SG_ACTION_DONTCARE"); break;
+            case SG_ACTION_LOAD: igText("    SG_ACTION_LOAD"); break;
+            case SG_ACTION_DONTCARE: igText("    SG_ACTION_DONTCARE"); break;
             default:
-                ImGui::Text("    SG_ACTION_CLEAR: %.3f, %.3f, %.3f, %.3f",
+                igText("    SG_ACTION_CLEAR: %.3f, %.3f, %.3f, %.3f",
                     c_att->val[0],
                     c_att->val[1],
                     c_att->val[2],
@@ -3062,18 +3149,18 @@ _SOKOL_PRIVATE void _sg_imgui_draw_passaction_panel(sg_imgui_t* ctx, sg_pass pas
         }
     }
     const sg_depth_attachment_action* d_att = &action->depth;
-    ImGui::Text("  Depth Attachment:");
+    igText("  Depth Attachment:");
     switch (d_att->action) {
-        case SG_ACTION_LOAD: ImGui::Text("    SG_ACTION_LOAD"); break;
-        case SG_ACTION_DONTCARE: ImGui::Text("    SG_ACTION_DONTCARE"); break;
-        default: ImGui::Text("    SG_ACTION_CLEAR: %.3f", d_att->val); break;
+        case SG_ACTION_LOAD: igText("    SG_ACTION_LOAD"); break;
+        case SG_ACTION_DONTCARE: igText("    SG_ACTION_DONTCARE"); break;
+        default: igText("    SG_ACTION_CLEAR: %.3f", d_att->val); break;
     }
     const sg_stencil_attachment_action* s_att = &action->stencil;
-    ImGui::Text("  Stencil Attachment");
+    igText("  Stencil Attachment");
     switch (s_att->action) {
-        case SG_ACTION_LOAD: ImGui::Text("    SG_ACTION_LOAD"); break;
-        case SG_ACTION_DONTCARE: ImGui::Text("    SG_ACTION_DONTCARE"); break;
-        default: ImGui::Text("    SG_ACTION_CLEAR: 0x%02X", s_att->val); break;
+        case SG_ACTION_LOAD: igText("    SG_ACTION_LOAD"); break;
+        case SG_ACTION_DONTCARE: igText("    SG_ACTION_DONTCARE"); break;
+        default: igText("    SG_ACTION_CLEAR: 0x%02X", s_att->val); break;
     }
 }
 
@@ -3083,11 +3170,11 @@ _SOKOL_PRIVATE void _sg_imgui_draw_capture_panel(sg_imgui_t* ctx) {
         return;
     }
     sg_imgui_capture_item_t* item = _sg_imgui_capture_read_item_at(ctx, sel_item_index);
-    ImGui::BeginChild("capture_item", ImVec2(0, 0), false);
-    ImGui::PushStyleColor(ImGuiCol_Text, item->color);
-    ImGui::Text("%s", _sg_imgui_capture_item_string(ctx, sel_item_index, item).buf);
-    ImGui::PopStyleColor();
-    ImGui::Separator();
+    igBeginChild("capture_item", IMVEC2(0, 0), false, 0);
+    igPushStyleColorU32(ImGuiCol_Text, item->color);
+    igText("%s", _sg_imgui_capture_item_string(ctx, sel_item_index, item).buf);
+    igPopStyleColor(1);
+    igSeparator();
     switch (item->cmd) {
         case SG_IMGUI_CMD_RESET_STATE_CACHE:
             break;
@@ -3138,7 +3225,7 @@ _SOKOL_PRIVATE void _sg_imgui_draw_capture_panel(sg_imgui_t* ctx) {
             break;
         case SG_IMGUI_CMD_BEGIN_PASS:
             _sg_imgui_draw_passaction_panel(ctx, item->args.begin_pass.pass, &item->args.begin_pass.action);
-            ImGui::Separator();
+            igSeparator();
             _sg_imgui_draw_pass_panel(ctx, item->args.begin_pass.pass);
             break;
         case SG_IMGUI_CMD_APPLY_VIEWPORT:
@@ -3205,33 +3292,33 @@ _SOKOL_PRIVATE void _sg_imgui_draw_capture_panel(sg_imgui_t* ctx) {
         default:
             break;
     }
-    ImGui::EndChild();
+    igEndChild();
 }
 
 _SOKOL_PRIVATE void _sg_imgui_draw_caps_panel(sg_imgui_t* ctx) {
-    ImGui::Text("Backend: %s\n\n", _sg_imgui_backend_string(sg_query_backend()));
+    igText("Backend: %s\n\n", _sg_imgui_backend_string(sg_query_backend()));
     sg_features f = sg_query_features();
-    ImGui::Text("Features:");
-    ImGui::Text("    instancing: %s", _sg_imgui_bool_string(f.instancing));
-    ImGui::Text("    origin_top_left: %s", _sg_imgui_bool_string(f.origin_top_left));
-    ImGui::Text("    multiple_render_targets: %s", _sg_imgui_bool_string(f.multiple_render_targets));
-    ImGui::Text("    msaa_render_targets: %s", _sg_imgui_bool_string(f.msaa_render_targets));
-    ImGui::Text("    imagetype_3d: %s", _sg_imgui_bool_string(f.imagetype_3d));
-    ImGui::Text("    imagetype_array: %s", _sg_imgui_bool_string(f.imagetype_array));
+    igText("Features:");
+    igText("    instancing: %s", _sg_imgui_bool_string(f.instancing));
+    igText("    origin_top_left: %s", _sg_imgui_bool_string(f.origin_top_left));
+    igText("    multiple_render_targets: %s", _sg_imgui_bool_string(f.multiple_render_targets));
+    igText("    msaa_render_targets: %s", _sg_imgui_bool_string(f.msaa_render_targets));
+    igText("    imagetype_3d: %s", _sg_imgui_bool_string(f.imagetype_3d));
+    igText("    imagetype_array: %s", _sg_imgui_bool_string(f.imagetype_array));
     sg_limits l = sg_query_limits();
-    ImGui::Text("\nLimits:\n");
-    ImGui::Text("    max_image_size_2d: %d", l.max_image_size_2d);
-    ImGui::Text("    max_image_size_cube: %d", l.max_image_size_cube);
-    ImGui::Text("    max_image_size_3d: %d", l.max_image_size_3d);
-    ImGui::Text("    max_image_size_array: %d", l.max_image_size_array);
-    ImGui::Text("    max_image_array_layers: %d", l.max_image_array_layers);
-    ImGui::Text("    max_vertex_attrs: %d", l.max_vertex_attrs);
-    ImGui::Text("\nUsable Pixelformats:");
+    igText("\nLimits:\n");
+    igText("    max_image_size_2d: %d", l.max_image_size_2d);
+    igText("    max_image_size_cube: %d", l.max_image_size_cube);
+    igText("    max_image_size_3d: %d", l.max_image_size_3d);
+    igText("    max_image_size_array: %d", l.max_image_size_array);
+    igText("    max_image_array_layers: %d", l.max_image_array_layers);
+    igText("    max_vertex_attrs: %d", l.max_vertex_attrs);
+    igText("\nUsable Pixelformats:");
     for (int i = (int)(SG_PIXELFORMAT_NONE+1); i < (int)_SG_PIXELFORMAT_NUM; i++) {
         sg_pixel_format fmt = (sg_pixel_format)i;
         sg_pixelformat_info info = sg_query_pixelformat(fmt);
         if (info.sample) {
-            ImGui::Text("  %s: %s%s%s%s%s%s",
+            igText("  %s: %s%s%s%s%s%s",
                 _sg_imgui_pixelformat_string(fmt),
                 info.sample ? "SAMPLE ":"",
                 info.filter ? "FILTER ":"",
@@ -3409,11 +3496,11 @@ SOKOL_API_IMPL void sg_imgui_draw_buffers_window(sg_imgui_t* ctx) {
     if (!ctx->buffers.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(440, 280), ImGuiCond_Once);
-    if (ImGui::Begin("Buffers", &ctx->buffers.open)) {
+    igSetNextWindowSize(IMVEC2(440, 280), ImGuiCond_Once);
+    if (igBegin("Buffers", &ctx->buffers.open, 0)) {
         sg_imgui_draw_buffers_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_images_window(sg_imgui_t* ctx) {
@@ -3421,11 +3508,11 @@ SOKOL_API_IMPL void sg_imgui_draw_images_window(sg_imgui_t* ctx) {
     if (!ctx->images.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Images", &ctx->images.open)) {
+    igSetNextWindowSize(IMVEC2(440, 400), ImGuiCond_Once);
+    if (igBegin("Images", &ctx->images.open, 0)) {
         sg_imgui_draw_images_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_shaders_window(sg_imgui_t* ctx) {
@@ -3433,11 +3520,11 @@ SOKOL_API_IMPL void sg_imgui_draw_shaders_window(sg_imgui_t* ctx) {
     if (!ctx->shaders.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Shaders", &ctx->shaders.open)) {
+    igSetNextWindowSize(IMVEC2(440, 400), ImGuiCond_Once);
+    if (igBegin("Shaders", &ctx->shaders.open, 0)) {
         sg_imgui_draw_shaders_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_pipelines_window(sg_imgui_t* ctx) {
@@ -3445,11 +3532,11 @@ SOKOL_API_IMPL void sg_imgui_draw_pipelines_window(sg_imgui_t* ctx) {
     if (!ctx->pipelines.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(540, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Pipelines", &ctx->pipelines.open)) {
+    igSetNextWindowSize(IMVEC2(540, 400), ImGuiCond_Once);
+    if (igBegin("Pipelines", &ctx->pipelines.open, 0)) {
         sg_imgui_draw_pipelines_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_passes_window(sg_imgui_t* ctx) {
@@ -3457,11 +3544,11 @@ SOKOL_API_IMPL void sg_imgui_draw_passes_window(sg_imgui_t* ctx) {
     if (!ctx->passes.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Passes", &ctx->passes.open)) {
+    igSetNextWindowSize(IMVEC2(440, 400), ImGuiCond_Once);
+    if (igBegin("Passes", &ctx->passes.open, 0)) {
         sg_imgui_draw_passes_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_capture_window(sg_imgui_t* ctx) {
@@ -3469,11 +3556,11 @@ SOKOL_API_IMPL void sg_imgui_draw_capture_window(sg_imgui_t* ctx) {
     if (!ctx->capture.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(640, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Frame Capture", &ctx->capture.open)) {
+    igSetNextWindowSize(IMVEC2(640, 400), ImGuiCond_Once);
+    if (igBegin("Frame Capture", &ctx->capture.open, 0)) {
         sg_imgui_draw_capture_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_capabilities_window(sg_imgui_t* ctx) {
@@ -3481,52 +3568,52 @@ SOKOL_API_IMPL void sg_imgui_draw_capabilities_window(sg_imgui_t* ctx) {
     if (!ctx->caps.open) {
         return;
     }
-    ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiCond_Once);
-    if (ImGui::Begin("Capabilities", &ctx->caps.open)) {
+    igSetNextWindowSize(IMVEC2(440, 400), ImGuiCond_Once);
+    if (igBegin("Capabilities", &ctx->caps.open, 0)) {
         sg_imgui_draw_capabilities_content(ctx);
     }
-    ImGui::End();
+    igEnd();
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_buffers_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_buffer_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_buffer_panel(ctx, ctx->buffers.sel_buf);
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_images_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_image_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_image_panel(ctx, ctx->images.sel_img);
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_shaders_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_shader_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_shader_panel(ctx, ctx->shaders.sel_shd);
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_pipelines_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_pipeline_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_pipeline_panel(ctx, ctx->pipelines.sel_pip);
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_passes_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_pass_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_pass_panel(ctx, ctx->passes.sel_pass);
 }
 
 SOKOL_API_IMPL void sg_imgui_draw_capture_content(sg_imgui_t* ctx) {
     SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
     _sg_imgui_draw_capture_list(ctx);
-    ImGui::SameLine();
+    igSameLine(0,-1);
     _sg_imgui_draw_capture_panel(ctx);
 }