aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAndre Weissflog <floooh@gmail.com>2019-03-05 18:20:17 +0100
committerGitHub <noreply@github.com>2019-03-05 18:20:17 +0100
commit04bbb7ac588db2a65064575dbedca9042d2c039e (patch)
treee6e0e90d0d464fac471cfecc002f3f1a26016aa8
parent6570419898b72337c619be1d0f3cd66350ddc7a5 (diff)
Debugging UI extension headers via Dear ImGui (#125)
This PR adds optional debugging UI extension headers (or rather: currently only one for sokol_gfx.h called sokol_gfx_imgui.h). sokol_gfx.h gets a new API function to install callback functions for tracing the public sokol_gfx.h API calls.
Diffstat
-rw-r--r--README.md14
-rw-r--r--fips.yml2
-rw-r--r--imgui/README.md538
-rw-r--r--imgui/sokol_gfx_imgui.h3637
-rw-r--r--sokol_gfx.h811
5 files changed, 4734 insertions, 268 deletions
diff --git a/README.md b/README.md
index 5c658f95..e97b1624 100644
--- a/README.md
+++ b/README.md
@@ -407,6 +407,20 @@ Mainly some "missing features" for desktop apps:
# Updates
+- **05-Mar-2019**: sokol_gfx.h now has a 'trace hook' API, and I have started
+implementing optional debug-inspection-UI headers on top of Dear ImGui:
+ - sokol_gfx.h has a new function sg_install_trace_hook(), this allows
+ you to install a callback function for each public sokol_gfx.h function
+ (and a couple or error callbacks). For more details, search for "TRACE HOOKS"
+ in sokol_gfx.h
+ - I have started a new 'subproject' in the 'imgui' directory, this will
+ contain a slowly growing set of optional debug-inspection-UI headers
+ which allow to peek under the hood of the Sokol headers. The UIs are
+ implemented with [Dear ImGui](https://github.com/ocornut/imgui). Again,
+ see the README in the 'imgui' directory and the headers in there
+ for details, and check out the live demos on the [Sokol Sample Webpage](https://floooh.github.io/sokol-html5/)
+ (click on the little UI buttons in the top right corner of each thumbnail)
+
- **21-Feb-2019**: sokol_app.h and sokol_audio.h now have an alternative
set of callbacks with user_data arguments. This is useful if you don't
want or cannot store your own application state in global variables.
diff --git a/fips.yml b/fips.yml
index 93f5c31f..f144e02b 100644
--- a/fips.yml
+++ b/fips.yml
@@ -1,2 +1,2 @@
exports:
- header-dirs: [ . ] \ No newline at end of file
+ header-dirs: [ ".", "imgui" ]
diff --git a/imgui/README.md b/imgui/README.md
new file mode 100644
index 00000000..28548dc0
--- /dev/null
+++ b/imgui/README.md
@@ -0,0 +1,538 @@
+# Sokol Debug Inspection UIs
+
+This directory contains optional 'extension headers' which implement debug
+inspection UIs for various Sokol headers implemented with [Dear
+ImGui](https://github.com/ocornut/imgui).
+
+## Integration Howto
+
+These are the steps to add the debug inspection UIs to your own project.
+
+### 1. Compile the implementation as C++ (or Objective-C++)
+
+Dear ImGui is a C++ library, and offers a C++ API. This means the implementation
+of the debug inspection headers is also written in C++, and
+must be compiled in C++ or Objective-C++ mode.
+
+### 2. Compile the Sokol headers with trace-hooks enabled
+
+The debug inspection headers may need to *hook into* the Sokol APIs via
+callback functions. These API callbacks are called **trace hooks** and must
+be enabled by defining ```SOKOL_TRACE_HOOKS``` before including the
+implementation.
+
+### 3. Include "imgui.h" before the implementation
+
+The debug inspection headers don't include ```imgui.h``` themselves,
+instead the ImGui header must be included before the implementation.
+
+### 3. Include the debug UI implementations after the Sokol implementations
+
+The debug inspection headers need access to private data and functions of
+their associated Sokol header. This means the implementation of the
+debug inspection headers must be included **after** the implementation
+of the their associated Sokol headers. I'd recomment putting all the
+Sokol headers of a project into a single implementation file, together
+with all *extension headers*.
+
+```cpp
+// sokol-ui.cc
+//
+// Sokol header implementations and their debug inspection headers,
+// compiled as C++ code and with trace-hooks enabled. On macOS/iOS
+// this would need to be an Objective-C++ file instead (.mm extension).
+//
+#define SOKOL_IMPL
+#define SOKOL_TRACE_HOOKS
+#include "sokol_app.h"
+#include "sokol_gfx.h"
+#include "sokol_time.h"
+#include "imgui.h"
+#include "sokol_app_imgui.h"
+#include "sokol_gfx_imgui.h"
+```
+
+### 4. Provide your own ImGui renderer
+
+You need to provide your own ImGui initialization and rendering
+code. If you are using sokol_gfx.h together with sokol_app.h, you
+can just copy the code from the sokol-samples:
+
+```cpp
+#pragma once
+/*
+ Implements a Dear ImGui renderer on top of sokol_gfx.h for
+ the debug-visualization UIs.
+*/
+#include "sokol_app.h"
+#include "sokol_gfx.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+void imgui_init(int sample_count);
+void imgui_newframe(void);
+void imgui_draw(void);
+void imgui_event(const sapp_event* event);
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+//------------------------------------------------------------------------------
+#if defined(UI_IMPL)
+#include "imgui.h"
+
+typedef struct {
+ ImVec2 disp_size;
+} vs_params_t;
+
+static bool btn_down[SAPP_MAX_MOUSEBUTTONS];
+static bool btn_up[SAPP_MAX_MOUSEBUTTONS];
+static const int MaxVertices = (1<<17);
+static const int MaxIndices = MaxVertices * 3;
+static sg_pipeline imgui_pip;
+static sg_bindings imgui_bind;
+
+extern const char* vs_src_imgui;
+extern const char* fs_src_imgui;
+
+void imgui_init(int sample_count) {
+ ImGui::CreateContext();
+ ImGui::StyleColorsDark();
+ auto& style = ImGui::GetStyle();
+ style.WindowRounding = 0.0f;
+ style.WindowBorderSize = 1.0f;
+ style.Alpha = 1.0f;
+ auto& io = ImGui::GetIO();
+ io.Fonts->AddFontDefault();
+ io.IniFilename = nullptr;
+ io.KeyMap[ImGuiKey_Tab] = SAPP_KEYCODE_TAB;
+ io.KeyMap[ImGuiKey_LeftArrow] = SAPP_KEYCODE_LEFT;
+ io.KeyMap[ImGuiKey_RightArrow] = SAPP_KEYCODE_RIGHT;
+ io.KeyMap[ImGuiKey_UpArrow] = SAPP_KEYCODE_UP;
+ io.KeyMap[ImGuiKey_DownArrow] = SAPP_KEYCODE_DOWN;
+ io.KeyMap[ImGuiKey_PageUp] = SAPP_KEYCODE_PAGE_UP;
+ io.KeyMap[ImGuiKey_PageDown] = SAPP_KEYCODE_PAGE_DOWN;
+ io.KeyMap[ImGuiKey_Home] = SAPP_KEYCODE_HOME;
+ io.KeyMap[ImGuiKey_End] = SAPP_KEYCODE_END;
+ io.KeyMap[ImGuiKey_Delete] = SAPP_KEYCODE_DELETE;
+ io.KeyMap[ImGuiKey_Backspace] = SAPP_KEYCODE_BACKSPACE;
+ io.KeyMap[ImGuiKey_Space] = SAPP_KEYCODE_SPACE;
+ io.KeyMap[ImGuiKey_Enter] = SAPP_KEYCODE_ENTER;
+ io.KeyMap[ImGuiKey_Escape] = SAPP_KEYCODE_ESCAPE;
+ io.KeyMap[ImGuiKey_A] = SAPP_KEYCODE_A;
+ io.KeyMap[ImGuiKey_C] = SAPP_KEYCODE_C;
+ io.KeyMap[ImGuiKey_V] = SAPP_KEYCODE_V;
+ io.KeyMap[ImGuiKey_X] = SAPP_KEYCODE_X;
+ io.KeyMap[ImGuiKey_Y] = SAPP_KEYCODE_Y;
+ io.KeyMap[ImGuiKey_Z] = SAPP_KEYCODE_Z;
+
+ sg_push_debug_group("imgui init");
+
+ // dynamic vertex- and index-buffers for imgui-generated geometry
+ sg_buffer_desc vbuf_desc = { };
+ vbuf_desc.usage = SG_USAGE_STREAM;
+ vbuf_desc.size = MaxVertices * sizeof(ImDrawVert);
+ vbuf_desc.label = "imgui-vertices";
+ imgui_bind.vertex_buffers[0] = sg_make_buffer(&vbuf_desc);
+
+ sg_buffer_desc ibuf_desc = { };
+ ibuf_desc.type = SG_BUFFERTYPE_INDEXBUFFER;
+ ibuf_desc.usage = SG_USAGE_STREAM;
+ ibuf_desc.size = MaxIndices * sizeof(ImDrawIdx);
+ ibuf_desc.label = "imgui-indices";
+ imgui_bind.index_buffer = sg_make_buffer(&ibuf_desc);
+
+ // font texture for imgui's default font
+ unsigned char* font_pixels;
+ int font_width, font_height;
+ io.Fonts->GetTexDataAsRGBA32(&font_pixels, &font_width, &font_height);
+ sg_image_desc img_desc = { };
+ img_desc.width = font_width;
+ img_desc.height = font_height;
+ img_desc.pixel_format = SG_PIXELFORMAT_RGBA8;
+ img_desc.wrap_u = SG_WRAP_CLAMP_TO_EDGE;
+ img_desc.wrap_v = SG_WRAP_CLAMP_TO_EDGE;
+ img_desc.min_filter = SG_FILTER_LINEAR;
+ img_desc.mag_filter = SG_FILTER_LINEAR;
+ img_desc.content.subimage[0][0].ptr = font_pixels;
+ img_desc.content.subimage[0][0].size = font_width * font_height * 4;
+ img_desc.label = "imgui-font";
+ io.Fonts->TexID = (ImTextureID)(uintptr_t) sg_make_image(&img_desc).id;
+
+ // shader object for imgui rendering
+ sg_shader_desc shd_desc = { };
+ auto& ub = shd_desc.vs.uniform_blocks[0];
+ ub.size = sizeof(vs_params_t);
+ ub.uniforms[0].name = "disp_size";
+ ub.uniforms[0].type = SG_UNIFORMTYPE_FLOAT2;
+ shd_desc.fs.images[0].name = "tex";
+ shd_desc.fs.images[0].type = SG_IMAGETYPE_2D;
+ shd_desc.vs.source = vs_src_imgui;
+ shd_desc.fs.source = fs_src_imgui;
+ shd_desc.label = "imgui-shader";
+ sg_shader shd = sg_make_shader(&shd_desc);
+
+ // pipeline object for imgui rendering
+ sg_pipeline_desc pip_desc = { };
+ pip_desc.layout.buffers[0].stride = sizeof(ImDrawVert);
+ auto& attrs = pip_desc.layout.attrs;
+ attrs[0].name="position"; attrs[0].sem_name="POSITION"; attrs[0].offset=offsetof(ImDrawVert, pos); attrs[0].format=SG_VERTEXFORMAT_FLOAT2;
+ attrs[1].name="texcoord0"; attrs[1].sem_name="TEXCOORD"; attrs[1].offset=offsetof(ImDrawVert, uv); attrs[1].format=SG_VERTEXFORMAT_FLOAT2;
+ attrs[2].name="color0"; attrs[2].sem_name="COLOR"; attrs[2].offset=offsetof(ImDrawVert, col); attrs[2].format=SG_VERTEXFORMAT_UBYTE4N;
+ pip_desc.shader = shd;
+ pip_desc.index_type = SG_INDEXTYPE_UINT16;
+ pip_desc.blend.enabled = true;
+ pip_desc.blend.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA;
+ pip_desc.blend.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ pip_desc.blend.color_write_mask = SG_COLORMASK_RGB;
+ pip_desc.rasterizer.sample_count = sample_count;
+ pip_desc.label = "imgui-pipeline";
+ imgui_pip = sg_make_pipeline(&pip_desc);
+
+ sg_pop_debug_group();
+}
+
+void imgui_newframe(void) {
+ const int cur_width = sapp_width();
+ const int cur_height = sapp_height();
+ ImGuiIO& io = ImGui::GetIO();
+ io.DisplaySize = ImVec2(float(cur_width), float(cur_height));
+ io.DeltaTime = 1.0f / 60.0f;
+ for (int i = 0; i < SAPP_MAX_MOUSEBUTTONS; i++) {
+ if (btn_down[i]) {
+ btn_down[i] = false;
+ io.MouseDown[i] = true;
+ }
+ else if (btn_up[i]) {
+ btn_up[i] = false;
+ io.MouseDown[i] = false;
+ }
+ }
+ ImGui::NewFrame();
+}
+
+void imgui_draw(void) {
+ ImGui::Render();
+ ImDrawData* draw_data = ImGui::GetDrawData();
+ if (nullptr == draw_data) {
+ return;
+ }
+ if (draw_data->CmdListsCount == 0) {
+ return;
+ }
+
+ // render the command list
+ sg_push_debug_group("imgui");
+ sg_apply_pipeline(imgui_pip);
+ vs_params_t vs_params;
+ vs_params.disp_size.x = ImGui::GetIO().DisplaySize.x;
+ vs_params.disp_size.y = ImGui::GetIO().DisplaySize.y;
+ sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, &vs_params, sizeof(vs_params));
+ for (int cl_index = 0; cl_index < draw_data->CmdListsCount; cl_index++) {
+ const ImDrawList* cl = draw_data->CmdLists[cl_index];
+
+ // append vertices and indices to buffers, record start offsets in draw state
+ const int vtx_size = cl->VtxBuffer.size() * sizeof(ImDrawVert);
+ const int idx_size = cl->IdxBuffer.size() * sizeof(ImDrawIdx);
+ const int vb_offset = sg_append_buffer(imgui_bind.vertex_buffers[0], &cl->VtxBuffer.front(), vtx_size);
+ const int ib_offset = sg_append_buffer(imgui_bind.index_buffer, &cl->IdxBuffer.front(), idx_size);
+ /* don't render anything if the buffer is in overflow state (this is also
+ checked internally in sokol_gfx, draw calls that attempt from
+ overflowed buffers will be silently dropped)
+ */
+ if (sg_query_buffer_overflow(imgui_bind.vertex_buffers[0]) ||
+ sg_query_buffer_overflow(imgui_bind.index_buffer))
+ {
+ break;
+ }
+
+ ImTextureID tex_id = ImGui::GetIO().Fonts->TexID;
+ imgui_bind.vertex_buffer_offsets[0] = vb_offset;
+ imgui_bind.index_buffer_offset = ib_offset;
+ imgui_bind.fs_images[0].id = (uint32_t)(uintptr_t)tex_id;
+
+ sg_apply_bindings(&imgui_bind);
+ int base_element = 0;
+ for (const ImDrawCmd& pcmd : cl->CmdBuffer) {
+ if (pcmd.UserCallback) {
+ pcmd.UserCallback(cl, &pcmd);
+ }
+ else {
+ if (tex_id != pcmd.TextureId) {
+ tex_id = pcmd.TextureId;
+ imgui_bind.fs_images[0].id = (uint32_t)(uintptr_t)tex_id;
+ sg_apply_bindings(&imgui_bind);
+ }
+ const int scissor_x = (int) (pcmd.ClipRect.x);
+ const int scissor_y = (int) (pcmd.ClipRect.y);
+ const int scissor_w = (int) (pcmd.ClipRect.z - pcmd.ClipRect.x);
+ const int scissor_h = (int) (pcmd.ClipRect.w - pcmd.ClipRect.y);
+ sg_apply_scissor_rect(scissor_x, scissor_y, scissor_w, scissor_h, true);
+ sg_draw(base_element, pcmd.ElemCount, 1);
+ }
+ base_element += pcmd.ElemCount;
+ }
+ }
+ sg_pop_debug_group();
+}
+
+void imgui_event(const sapp_event* event) {
+ auto& io = ImGui::GetIO();
+ io.KeyAlt = (event->modifiers & SAPP_MODIFIER_ALT) != 0;
+ io.KeyCtrl = (event->modifiers & SAPP_MODIFIER_CTRL) != 0;
+ io.KeyShift = (event->modifiers & SAPP_MODIFIER_SHIFT) != 0;
+ io.KeySuper = (event->modifiers & SAPP_MODIFIER_SUPER) != 0;
+ switch (event->type) {
+ case SAPP_EVENTTYPE_MOUSE_DOWN:
+ io.MousePos.x = event->mouse_x;
+ io.MousePos.y = event->mouse_y;
+ btn_down[event->mouse_button] = true;
+ break;
+ case SAPP_EVENTTYPE_MOUSE_UP:
+ io.MousePos.x = event->mouse_x;
+ io.MousePos.y = event->mouse_y;
+ btn_up[event->mouse_button] = true;
+ break;
+ case SAPP_EVENTTYPE_MOUSE_MOVE:
+ io.MousePos.x = event->mouse_x;
+ io.MousePos.y = event->mouse_y;
+ break;
+ case SAPP_EVENTTYPE_MOUSE_ENTER:
+ case SAPP_EVENTTYPE_MOUSE_LEAVE:
+ for (int i = 0; i < 3; i++) {
+ btn_down[i] = false;
+ btn_up[i] = false;
+ io.MouseDown[i] = false;
+ }
+ break;
+ case SAPP_EVENTTYPE_MOUSE_SCROLL:
+ io.MouseWheelH = event->scroll_x;
+ io.MouseWheel = event->scroll_y;
+ break;
+ case SAPP_EVENTTYPE_TOUCHES_BEGAN:
+ btn_down[0] = true;
+ io.MousePos.x = event->touches[0].pos_x;
+ io.MousePos.y = event->touches[0].pos_y;
+ break;
+ case SAPP_EVENTTYPE_TOUCHES_MOVED:
+ io.MousePos.x = event->touches[0].pos_x;
+ io.MousePos.y = event->touches[0].pos_y;
+ break;
+ case SAPP_EVENTTYPE_TOUCHES_ENDED:
+ btn_up[0] = true;
+ io.MousePos.x = event->touches[0].pos_x;
+ io.MousePos.y = event->touches[0].pos_y;
+ break;
+ case SAPP_EVENTTYPE_TOUCHES_CANCELLED:
+ btn_up[0] = btn_down[0] = false;
+ break;
+ case SAPP_EVENTTYPE_KEY_DOWN:
+ io.KeysDown[event->key_code] = true;
+ break;
+ case SAPP_EVENTTYPE_KEY_UP:
+ io.KeysDown[event->key_code] = false;
+ break;
+ case SAPP_EVENTTYPE_CHAR:
+ io.AddInputCharacter((ImWchar)event->char_code);
+ break;
+ default:
+ break;
+ }
+}
+
+#if defined(SOKOL_GLCORE33)
+const char* vs_src_imgui =
+ "#version 330\n"
+ "uniform vec2 disp_size;\n"
+ "in vec2 position;\n"
+ "in vec2 texcoord0;\n"
+ "in vec4 color0;\n"
+ "out vec2 uv;\n"
+ "out vec4 color;\n"
+ "void main() {\n"
+ " gl_Position = vec4(((position/disp_size)-0.5)*vec2(2.0,-2.0), 0.5, 1.0);\n"
+ " uv = texcoord0;\n"
+ " color = color0;\n"
+ "}\n";
+const char* fs_src_imgui =
+ "#version 330\n"
+ "uniform sampler2D tex;\n"
+ "in vec2 uv;\n"
+ "in vec4 color;\n"
+ "out vec4 frag_color;\n"
+ "void main() {\n"
+ " frag_color = texture(tex, uv) * color;\n"
+ "}\n";
+#elif defined(SOKOL_GLES2) || defined(SOKOL_GLES3)
+const char* vs_src_imgui =
+ "uniform vec2 disp_size;\n"
+ "attribute vec2 position;\n"
+ "attribute vec2 texcoord0;\n"
+ "attribute vec4 color0;\n"
+ "varying vec2 uv;\n"
+ "varying vec4 color;\n"
+ "void main() {\n"
+ " gl_Position = vec4(((position/disp_size)-0.5)*vec2(2.0,-2.0), 0.5, 1.0);\n"
+ " uv = texcoord0;\n"
+ " color = color0;\n"
+ "}\n";
+const char* fs_src_imgui =
+ "precision mediump float;\n"
+ "uniform sampler2D tex;\n"
+ "varying vec2 uv;\n"
+ "varying vec4 color;\n"
+ "void main() {\n"
+ " gl_FragColor = texture2D(tex, uv) * color;\n"
+ "}\n";
+#elif defined(SOKOL_METAL)
+const char* vs_src_imgui =
+ "#include <metal_stdlib>\n"
+ "using namespace metal;\n"
+ "struct params_t {\n"
+ " float2 disp_size;\n"
+ "};\n"
+ "struct vs_in {\n"
+ " float2 pos [[attribute(0)]];\n"
+ " float2 uv [[attribute(1)]];\n"
+ " float4 color [[attribute(2)]];\n"
+ "};\n"
+ "struct vs_out {\n"
+ " float4 pos [[position]];\n"
+ " float2 uv;\n"
+ " float4 color;\n"
+ "};\n"
+ "vertex vs_out _main(vs_in in [[stage_in]], constant params_t& params [[buffer(0)]]) {\n"
+ " vs_out out;\n"
+ " out.pos = float4(((in.pos / params.disp_size)-0.5)*float2(2.0,-2.0), 0.5, 1.0);\n"
+ " out.uv = in.uv;\n"
+ " out.color = in.color;\n"
+ " return out;\n"
+ "}\n";
+const char* fs_src_imgui =
+ "#include <metal_stdlib>\n"
+ "using namespace metal;\n"
+ "struct fs_in {\n"
+ " float2 uv;\n"
+ " float4 color;\n"
+ "};\n"
+ "fragment float4 _main(fs_in in [[stage_in]], texture2d<float> tex [[texture(0)]], sampler smp [[sampler(0)]]) {\n"
+ " return tex.sample(smp, in.uv) * in.color;\n"
+ "}\n";
+#elif defined(SOKOL_D3D11)
+const char* vs_src_imgui =
+ "cbuffer params {\n"
+ " float2 disp_size;\n"
+ "};\n"
+ "struct vs_in {\n"
+ " float2 pos: POSITION;\n"
+ " float2 uv: TEXCOORD0;\n"
+ " float4 color: COLOR0;\n"
+ "};\n"
+ "struct vs_out {\n"
+ " float2 uv: TEXCOORD0;\n"
+ " float4 color: COLOR0;\n"
+ " float4 pos: SV_Position;\n"
+ "};\n"
+ "vs_out main(vs_in inp) {\n"
+ " vs_out outp;\n"
+ " outp.pos = float4(((inp.pos/disp_size)-0.5)*float2(2.0,-2.0), 0.5, 1.0);\n"
+ " outp.uv = inp.uv;\n"
+ " outp.color = inp.color;\n"
+ " return outp;\n"
+ "}\n";
+const char* fs_src_imgui =
+ "Texture2D<float4> tex: register(t0);\n"
+ "sampler smp: register(s0);\n"
+ "float4 main(float2 uv: TEXCOORD0, float4 color: COLOR0): SV_Target0 {\n"
+ " return tex.Sample(smp, uv) * color;\n"
+ "}\n";
+#else
+#error "No sokol-gfx backend selected"
+#endif
+
+#endif /* UI_IMPL */
+```
+
+### 5. Add UI init- and rendering-calls to your code
+
+All debug inspection headers follow the same API pattern (here shown
+with ```sokol_gfx_imgui.h``` as an example):
+
+- a struct to store all state
+- an init-function to initialize this struct to a good state
+- a one-in-all draw-function which is called per frame
+- ...and a discard function called at shutdown
+
+```cpp
+static sg_imgui_t sg_imgui;
+
+void init(void) {
+ ...
+ /* initialize the sokol-gfx debug inspection UI */
+ sg_imgui_init(&sg_imgui)
+ ...
+}
+
+void draw_frame(void) {
+ ...
+ /* draw the debug inspection UI via Dear ImGui calls */
+ sg_imgui_draw(&sg_imgui);
+ ...
+}
+
+void shutdown(void) {
+ ...
+ sg_imgui_discard(&sg_imgui);
+ ...
+}
+```
+
+When running this code, nothing will be rendered because all debug inspection
+windows are in closed state. Opening and closing the windows is done
+directly by toggling public bool members of the state struct.
+
+For instance in with sokol_gfx_imgui.h:
+
+```cpp
+/* open all sokol_gfx_imgui.h windows */
+sg_imgui.buffers.open = true
+sg_imgui.images.open = true;
+sg_imgui.shaders.open = true;
+sg_imgui.pipelines.open = true;
+sg_imgui.passes.open = true;
+sg_imgui.capture.open = true;
+```
+
+Exposing the open state as booleans has been done to make it easier to
+toggle the window visibility with other ImGui functions. For instance
+you could build a menu like this:
+
+```cpp
+if (ImGui::BeginMainMenuBar()) {
+ if (ImGui::BeginMenu("sokol-gfx")) {
+ ImGui::MenuItem("Buffers", 0, &sg_imgui.buffers.open);
+ ImGui::MenuItem("Images", 0, &sg_imgui.images.open);
+ ImGui::MenuItem("Shaders", 0, &sg_imgui.shaders.open);
+ ImGui::MenuItem("Pipelines", 0, &sg_imgui.pipelines.open);
+ ImGui::MenuItem("Passes", 0, &sg_imgui.passes.open);
+ ImGui::MenuItem("Calls", 0, &sg_imgui.capture.open);
+ ImGui::EndMenu();
+ }
+ ImGui::EndMainMenuBar();
+}
+```
+
+The debug inspection headers also offer more granular drawing functions
+for more flexible integration into your own UI, for example the following
+```sokol_gfx_imgui.h``` functions only draw the window content, so you
+can integrate the UIs into your own windows:
+
+```cpp
+void sg_imgui_draw_buffers_content(sg_imgui_t* ctx);
+void sg_imgui_draw_images_content(sg_imgui_t* ctx);
+void sg_imgui_draw_shaders_content(sg_imgui_t* ctx);
+void sg_imgui_draw_pipelines_content(sg_imgui_t* ctx);
+void sg_imgui_draw_passes_content(sg_imgui_t* ctx);
+void sg_imgui_draw_capture_content(sg_imgui_t* ctx);
+```
diff --git a/imgui/sokol_gfx_imgui.h b/imgui/sokol_gfx_imgui.h
new file mode 100644
index 00000000..1384de2e
--- /dev/null
+++ b/imgui/sokol_gfx_imgui.h
@@ -0,0 +1,3637 @@
+#pragma once
+/*
+ sokol_gfx_imgui.h -- debug-inspection UI for sokol_gfx.h using Dear ImGui
+
+ This is an extension header for sokol_gfx.h, this means sokol_gfx_imgui.h
+ must be included *after* sokol_gfx.h both for the implementation
+ and declaration.
+
+ You also need to include imgui.h before including the implementation
+ of sokol_gfx_imgui.h.
+
+ The implementation must be compiled as C++ or Objective-C++, the
+ declaration can be included in plain C sources.
+
+ The sokol_gfx_imgui.h header recognizes the same preprocessor defines
+ that have been set for the actual Sokol headers (for instance
+ SOKOL_IMPL, SOKOL_MALLOC, SOKOL_LOG, etc...).
+
+ STEP BY STEP:
+ =============
+ --- include the sokol_gfx_imgui.h header after the actual Sokol header
+ implementations and the imgui.h header (and make sure this code
+ is compiled as C++ or Objective-C++)
+
+ --- add a Dear ImGui renderer to your application, and the basic
+ per-frame code to render an ImGui UI.
+
+ --- create an sg_imgui_t struct (which must be preserved between frames)
+ and initialize it with:
+
+ sg_imgui_init(&sg_imgui);
+
+ --- somewhere in the per-frame code call:
+
+ sg_imgui_draw(&sg_imgui)
+
+ this won't draw anything yet, since no windows are open.
+
+ --- open and close windows directly by setting the following public
+ booleans in the sg_imgui_t struct:
+
+ sg_imgui.buffers.open = true;
+ sg_imgui.images.open = true;
+ sg_imgui.shaders.open = true;
+ sg_imgui.pipelines.open = true;
+ sg_imgui.passes.open = true;
+ sg_imgui.capture.open = true;
+
+ ...for instance, to control the window visibility through
+ menu items, the following code can be used:
+
+ if (ImGui::BeginMainMenuBar()) {
+ if (ImGui::BeginMenu("sokol-gfx")) {
+ ImGui::MenuItem("Buffers", 0, &sg_imgui.buffers.open);
+ ImGui::MenuItem("Images", 0, &sg_imgui.images.open);
+ ImGui::MenuItem("Shaders", 0, &sg_imgui.shaders.open);
+ ImGui::MenuItem("Pipelines", 0, &sg_imgui.pipelines.open);
+ ImGui::MenuItem("Passes", 0, &sg_imgui.passes.open);
+ ImGui::MenuItem("Calls", 0, &sg_imgui.capture.open);
+ ImGui::EndMenu();
+ }
+ ImGui::EndMainMenuBar();
+ }
+
+ --- finally before application shutdown, call:
+
+ sg_imgui_discard(&sg_imgui);
+
+ ...this is not strictly necessary because the application exits
+ anyway, but not doing this may trigger memory leak detection tools.
+
+
+ ALTERNATIVE DRAWING FUNCTIONS:
+ ==============================
+ Instead of the convenient, but all-in-one sg_imgui_draw() function,
+ you can also use the following granular functions which might allow
+ better integration with your existing UI:
+
+ The following functions only render the window *content* (so you
+ can integrate the UI into you own windows):
+
+ void sg_imgui_draw_buffers_content(sg_imgui_t* ctx);
+ void sg_imgui_draw_images_content(sg_imgui_t* ctx);
+ void sg_imgui_draw_shaders_content(sg_imgui_t* ctx);
+ void sg_imgui_draw_pipelines_content(sg_imgui_t* ctx);
+ void sg_imgui_draw_passes_content(sg_imgui_t* ctx);
+ void sg_imgui_draw_capture_content(sg_imgui_t* ctx);
+
+ And these are the 'full window' drawing functions:
+
+ void sg_imgui_draw_buffers_window(sg_imgui_t* ctx);
+ void sg_imgui_draw_images_window(sg_imgui_t* ctx);
+ void sg_imgui_draw_shaders_window(sg_imgui_t* ctx);
+ void sg_imgui_draw_pipelines_window(sg_imgui_t* ctx);
+ void sg_imgui_draw_passes_window(sg_imgui_t* ctx);
+ void sg_imgui_draw_capture_window(sg_imgui_t* ctx);
+
+ Finer-grained drawing functions may be moved to the public API
+ in the future as needed.
+
+
+
+ zlib/libpng license
+
+ Copyright (c) 2018 Andre Weissflog
+
+ This software is provided 'as-is', without any express or implied warranty.
+ In no event will the authors be held liable for any damages arising from the
+ use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software in a
+ product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must not
+ be misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source
+ distribution.
+*/
+#include <stdint.h>
+#include <stdbool.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define SG_IMGUI_STRBUF_LEN (96)
+/* max number of captured calls per frame */
+#define SG_IMGUI_MAX_FRAMECAPTURE_ITEMS (4096)
+
+typedef struct {
+ char buf[SG_IMGUI_STRBUF_LEN];
+} sg_imgui_str_t;
+
+typedef struct {
+ sg_buffer res_id;
+ sg_imgui_str_t label;
+ sg_buffer_desc desc;
+} sg_imgui_buffer_t;
+
+typedef struct {
+ sg_image res_id;
+ float ui_scale;
+ sg_imgui_str_t label;
+ sg_image_desc desc;
+} sg_imgui_image_t;
+
+typedef struct {
+ sg_shader res_id;
+ sg_imgui_str_t label;
+ sg_imgui_str_t vs_entry;
+ sg_imgui_str_t vs_image_name[SG_MAX_SHADERSTAGE_IMAGES];
+ sg_imgui_str_t vs_uniform_name[SG_MAX_SHADERSTAGE_UBS][SG_MAX_UB_MEMBERS];
+ sg_imgui_str_t fs_entry;
+ sg_imgui_str_t fs_image_name[SG_MAX_SHADERSTAGE_IMAGES];
+ sg_imgui_str_t fs_uniform_name[SG_MAX_SHADERSTAGE_UBS][SG_MAX_UB_MEMBERS];
+ sg_shader_desc desc;
+} sg_imgui_shader_t;
+
+typedef struct {
+ sg_pipeline res_id;
+ sg_imgui_str_t label;
+ sg_imgui_str_t attr_name[SG_MAX_VERTEX_ATTRIBUTES];
+ sg_imgui_str_t attr_sem_name[SG_MAX_VERTEX_ATTRIBUTES];
+ sg_pipeline_desc desc;
+} sg_imgui_pipeline_t;
+
+typedef struct {
+ sg_pass res_id;
+ sg_imgui_str_t label;
+ float color_image_scale[SG_MAX_COLOR_ATTACHMENTS];
+ float ds_image_scale;
+} sg_imgui_pass_t;
+
+typedef struct {
+ bool open;
+ int num_slots;
+ uint32_t sel_id;
+ sg_imgui_buffer_t* slots;
+} sg_imgui_buffers_t;
+
+typedef struct {
+ bool open;
+ int num_slots;
+ uint32_t sel_id;
+ sg_imgui_image_t* slots;
+} sg_imgui_images_t;
+
+typedef struct {
+ bool open;
+ int num_slots;
+ uint32_t sel_id;
+ sg_imgui_shader_t* slots;
+} sg_imgui_shaders_t;
+
+typedef struct {
+ bool open;
+ int num_slots;
+ uint32_t sel_id;
+ sg_imgui_pipeline_t* slots;
+} sg_imgui_pipelines_t;
+
+typedef struct {
+ bool open;
+ int num_slots;
+ uint32_t sel_id;
+ sg_imgui_pass_t* slots;
+} sg_imgui_passes_t;
+
+typedef enum {
+ SG_IMGUI_CMD_INVALID,
+ SG_IMGUI_CMD_QUERY_FEATURE,
+ SG_IMGUI_CMD_RESET_STATE_CACHE,
+ SG_IMGUI_CMD_MAKE_BUFFER,
+ SG_IMGUI_CMD_MAKE_IMAGE,
+ SG_IMGUI_CMD_MAKE_SHADER,
+ SG_IMGUI_CMD_MAKE_PIPELINE,
+ SG_IMGUI_CMD_MAKE_PASS,
+ SG_IMGUI_CMD_DESTROY_BUFFER,
+ SG_IMGUI_CMD_DESTROY_IMAGE,
+ SG_IMGUI_CMD_DESTROY_SHADER,
+ SG_IMGUI_CMD_DESTROY_PIPELINE,
+ SG_IMGUI_CMD_DESTROY_PASS,
+ SG_IMGUI_CMD_UPDATE_BUFFER,
+ SG_IMGUI_CMD_UPDATE_IMAGE,
+ SG_IMGUI_CMD_APPEND_BUFFER,
+ SG_IMGUI_CMD_QUERY_BUFFER_OVERFLOW,
+ SG_IMGUI_CMD_QUERY_BUFFER_STATE,
+ SG_IMGUI_CMD_QUERY_IMAGE_STATE,
+ SG_IMGUI_CMD_QUERY_SHADER_STATE,
+ SG_IMGUI_CMD_QUERY_PIPELINE_STATE,
+ SG_IMGUI_CMD_QUERY_PASS_STATE,
+ SG_IMGUI_CMD_BEGIN_DEFAULT_PASS,
+ SG_IMGUI_CMD_BEGIN_PASS,
+ SG_IMGUI_CMD_APPLY_VIEWPORT,
+ SG_IMGUI_CMD_APPLY_SCISSOR_RECT,
+ SG_IMGUI_CMD_APPLY_PIPELINE,
+ SG_IMGUI_CMD_APPLY_BINDINGS,
+ SG_IMGUI_CMD_APPLY_UNIFORMS,
+ SG_IMGUI_CMD_DRAW,
+ SG_IMGUI_CMD_END_PASS,
+ SG_IMGUI_CMD_COMMIT,
+ SG_IMGUI_CMD_ALLOC_BUFFER,
+ SG_IMGUI_CMD_ALLOC_IMAGE,
+ SG_IMGUI_CMD_ALLOC_SHADER,
+ SG_IMGUI_CMD_ALLOC_PIPELINE,
+ SG_IMGUI_CMD_ALLOC_PASS,
+ SG_IMGUI_CMD_INIT_BUFFER,
+ SG_IMGUI_CMD_INIT_IMAGE,
+ SG_IMGUI_CMD_INIT_SHADER,
+ SG_IMGUI_CMD_INIT_PIPELINE,
+ SG_IMGUI_CMD_INIT_PASS,
+ SG_IMGUI_CMD_FAIL_BUFFER,
+ SG_IMGUI_CMD_FAIL_IMAGE,
+ SG_IMGUI_CMD_FAIL_SHADER,
+ SG_IMGUI_CMD_FAIL_PIPELINE,
+ SG_IMGUI_CMD_FAIL_PASS,
+ SG_IMGUI_CMD_PUSH_DEBUG_GROUP,
+ SG_IMGUI_CMD_POP_DEBUG_GROUP,
+ SG_IMGUI_CMD_ERR_BUFFER_POOL_EXHAUSTED,
+ SG_IMGUI_CMD_ERR_IMAGE_POOL_EXHAUSTED,
+ SG_IMGUI_CMD_ERR_SHADER_POOL_EXHAUSTED,
+ SG_IMGUI_CMD_ERR_PIPELINE_POOL_EXHAUSTED,
+ SG_IMGUI_CMD_ERR_PASS_POOL_EXHAUSTED,
+ SG_IMGUI_CMD_ERR_CONTEXT_MISMATCH,
+ SG_IMGUI_CMD_ERR_PASS_INVALID,
+ SG_IMGUI_CMD_ERR_DRAW_INVALID,
+ SG_IMGUI_CMD_ERR_BINDINGS_INVALID,
+} sg_imgui_cmd_t;
+
+typedef struct {
+ sg_feature feature;
+ bool result;
+} sg_imgui_args_query_feature_t;
+
+typedef struct {
+ sg_buffer result;
+} sg_imgui_args_make_buffer_t;
+
+typedef struct {
+ sg_image result;
+} sg_imgui_args_make_image_t;
+
+typedef struct {
+ sg_shader result;
+} sg_imgui_args_make_shader_t;
+
+typedef struct {
+ sg_pipeline result;
+} sg_imgui_args_make_pipeline_t;
+
+typedef struct {
+ sg_pass result;
+} sg_imgui_args_make_pass_t;
+
+typedef struct {
+ sg_buffer buffer;
+} sg_imgui_args_destroy_buffer_t;
+
+typedef struct {
+ sg_image image;
+} sg_imgui_args_destroy_image_t;
+
+typedef struct {
+ sg_shader shader;
+} sg_imgui_args_destroy_shader_t;
+
+typedef struct {
+ sg_pipeline pipeline;
+} sg_imgui_args_destroy_pipeline_t;
+
+typedef struct {
+ sg_pass pass;
+} sg_imgui_args_destroy_pass_t;
+
+typedef struct {
+ sg_buffer buffer;
+ int data_size;
+} sg_imgui_args_update_buffer_t;
+
+typedef struct {
+ sg_image image;
+} sg_imgui_args_update_image_t;
+
+typedef struct {
+ sg_buffer buffer;
+ int data_size;
+ int result;
+} sg_imgui_args_append_buffer_t;
+
+typedef struct {
+ sg_buffer buffer;
+ bool result;
+} sg_imgui_args_query_buffer_overflow_t;
+
+typedef struct {
+ sg_buffer buffer;
+ sg_resource_state result;
+} sg_imgui_args_query_buffer_state_t;
+
+typedef struct {
+ sg_image image;
+ sg_resource_state result;
+} sg_imgui_args_query_image_state_t;
+
+typedef struct {
+ sg_shader shader;
+ sg_resource_state result;
+} sg_imgui_args_query_shader_state_t;
+
+typedef struct {
+ sg_pipeline pipeline;
+ sg_resource_state result;
+} sg_imgui_args_query_pipeline_state_t;
+
+typedef struct {
+ sg_pass pass;
+ sg_resource_state result;
+} sg_imgui_args_query_pass_state_t;
+
+typedef struct {
+ sg_pass_action action;
+ int width;
+ int height;
+} sg_imgui_args_begin_default_pass_t;
+
+typedef struct {
+ sg_pass pass;
+ sg_pass_action action;
+} sg_imgui_args_begin_pass_t;
+
+typedef struct {
+ int x, y, width, height;
+ bool origin_top_left;
+} sg_imgui_args_apply_viewport_t;
+
+typedef struct {
+ int x, y, width, height;
+ bool origin_top_left;
+} sg_imgui_args_apply_scissor_rect_t;
+
+typedef struct {
+ sg_pipeline pipeline;
+} sg_imgui_args_apply_pipeline_t;
+
+typedef struct {
+ sg_bindings bindings;
+} sg_imgui_args_apply_bindings_t;
+
+typedef struct {
+ sg_shader_stage stage;
+ int ub_index;
+ const void* data;
+ int num_bytes;
+ sg_pipeline pipeline; /* the pipeline which was active at this call */
+ uint32_t ubuf_pos; /* start of copied data in capture buffer */
+} sg_imgui_args_apply_uniforms_t;
+
+typedef struct {
+ int base_element;
+ int num_elements;
+ int num_instances;
+} sg_imgui_args_draw_t;
+
+typedef struct {
+ sg_buffer result;
+} sg_imgui_args_alloc_buffer_t;
+
+typedef struct {
+ sg_image result;
+} sg_imgui_args_alloc_image_t;
+
+typedef struct {
+ sg_shader result;
+} sg_imgui_args_alloc_shader_t;
+
+typedef struct {
+ sg_pipeline result;
+} sg_imgui_args_alloc_pipeline_t;
+
+typedef struct {
+ sg_pass result;
+} sg_imgui_args_alloc_pass_t;
+
+typedef struct {
+ sg_buffer buffer;
+} sg_imgui_args_init_buffer_t;
+
+typedef struct {
+ sg_image image;
+} sg_imgui_args_init_image_t;
+
+typedef struct {
+ sg_shader shader;
+} sg_imgui_args_init_shader_t;
+
+typedef struct {
+ sg_pipeline pipeline;
+} sg_imgui_args_init_pipeline_t;
+
+typedef struct {
+ sg_pass pass;
+} sg_imgui_args_init_pass_t;
+
+typedef struct {
+ sg_buffer buffer;
+} sg_imgui_args_fail_buffer_t;
+
+typedef struct {
+ sg_image image;
+} sg_imgui_args_fail_image_t;
+
+typedef struct {
+ sg_shader shader;
+} sg_imgui_args_fail_shader_t;
+
+typedef struct {
+ sg_pipeline pipeline;
+} sg_imgui_args_fail_pipeline_t;
+
+typedef struct {
+ sg_pass pass;
+} sg_imgui_args_fail_pass_t;
+
+typedef struct {
+ sg_imgui_str_t name;
+} sg_imgui_args_push_debug_group_t;
+
+typedef union {
+ sg_imgui_args_query_feature_t query_feature;
+ sg_imgui_args_make_buffer_t make_buffer;
+ sg_imgui_args_make_image_t make_image;
+ sg_imgui_args_make_shader_t make_shader;
+ sg_imgui_args_make_pipeline_t make_pipeline;
+ sg_imgui_args_make_pass_t make_pass;
+ sg_imgui_args_destroy_buffer_t destroy_buffer;
+ sg_imgui_args_destroy_image_t destroy_image;
+ sg_imgui_args_destroy_shader_t destroy_shader;
+ sg_imgui_args_destroy_pipeline_t destroy_pipeline;
+ sg_imgui_args_destroy_pass_t destroy_pass;
+ sg_imgui_args_update_buffer_t update_buffer;
+ sg_imgui_args_update_image_t update_image;
+ sg_imgui_args_append_buffer_t append_buffer;
+ sg_imgui_args_query_buffer_overflow_t query_buffer_overflow;
+ sg_imgui_args_query_buffer_state_t query_buffer_state;
+ sg_imgui_args_query_image_state_t query_image_state;
+ sg_imgui_args_query_shader_state_t query_shader_state;
+ sg_imgui_args_query_pipeline_state_t query_pipeline_state;
+ sg_imgui_args_query_pass_state_t query_pass_state;
+ sg_imgui_args_begin_default_pass_t begin_default_pass;
+ sg_imgui_args_begin_pass_t begin_pass;
+ sg_imgui_args_apply_viewport_t apply_viewport;
+ sg_imgui_args_apply_scissor_rect_t apply_scissor_rect;
+ sg_imgui_args_apply_pipeline_t apply_pipeline;
+ sg_imgui_args_apply_bindings_t apply_bindings;
+ sg_imgui_args_apply_uniforms_t apply_uniforms;
+ sg_imgui_args_draw_t draw;
+ sg_imgui_args_alloc_buffer_t alloc_buffer;
+ sg_imgui_args_alloc_image_t alloc_image;
+ sg_imgui_args_alloc_shader_t alloc_shader;
+ sg_imgui_args_alloc_pipeline_t alloc_pipeline;
+ sg_imgui_args_alloc_pass_t alloc_pass;
+ sg_imgui_args_init_buffer_t init_buffer;
+ sg_imgui_args_init_image_t init_image;
+ sg_imgui_args_init_shader_t init_shader;
+ sg_imgui_args_init_pipeline_t init_pipeline;
+ sg_imgui_args_init_pass_t init_pass;
+ sg_imgui_args_fail_buffer_t fail_buffer;
+ sg_imgui_args_fail_image_t fail_image;
+ sg_imgui_args_fail_shader_t fail_shader;
+ sg_imgui_args_fail_pipeline_t fail_pipeline;
+ sg_imgui_args_fail_pass_t fail_pass;
+ sg_imgui_args_push_debug_group_t push_debug_group;
+} sg_imgui_args_t;
+
+typedef struct {
+ sg_imgui_cmd_t cmd;
+ uint32_t color;
+ sg_imgui_args_t args;
+} sg_imgui_capture_item_t;
+
+typedef struct {
+ uint32_t ubuf_size; /* size of uniform capture buffer in bytes */
+ uint32_t ubuf_pos; /* current uniform buffer pos */
+ uint8_t* ubuf; /* buffer for capturing uniform updates */
+ uint32_t num_items;
+ sg_imgui_capture_item_t items[SG_IMGUI_MAX_FRAMECAPTURE_ITEMS];
+} sg_imgui_capture_bucket_t;
+
+/* double-buffered call-capture buckets, one bucket is currently recorded,
+ the previous bucket is displayed
+*/
+typedef struct {
+ bool open;
+ uint32_t bucket_index; /* which bucket to record to, 0 or 1 */
+ uint32_t sel_item; /* currently selected capture item by index */
+ sg_imgui_capture_bucket_t bucket[2];
+} sg_imgui_capture_t;
+
+typedef struct {
+ uint32_t init_tag;
+ sg_imgui_buffers_t buffers;
+ sg_imgui_images_t images;
+ sg_imgui_shaders_t shaders;
+ sg_imgui_pipelines_t pipelines;
+ sg_imgui_passes_t passes;
+ sg_imgui_capture_t capture;
+ sg_trace_hooks hooks;
+} sg_imgui_t;
+
+SOKOL_API_DECL void sg_imgui_init(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_discard(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw(sg_imgui_t* ctx);
+
+SOKOL_API_DECL void sg_imgui_draw_buffers_content(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_images_content(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_shaders_content(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_pipelines_content(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_passes_content(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_capture_content(sg_imgui_t* ctx);
+
+SOKOL_API_DECL void sg_imgui_draw_buffers_window(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_images_window(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_shaders_window(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_pipelines_window(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_passes_window(sg_imgui_t* ctx);
+SOKOL_API_DECL void sg_imgui_draw_capture_window(sg_imgui_t* ctx);
+
+#if defined(__cplusplus)
+} /* extern "C" */
+#endif
+
+/*=== IMPLEMENTATION =========================================================*/
+#if defined SOKOL_IMPL
+#include <string.h>
+#include <stdio.h> /* snprintf */
+
+#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)
+
+/*--- UTILS ------------------------------------------------------------------*/
+_SOKOL_PRIVATE void* _sg_imgui_alloc(int size) {
+ SOKOL_ASSERT(size > 0);
+ return SOKOL_MALLOC(size);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_free(void* ptr) {
+ if (ptr) {
+ SOKOL_FREE(ptr);
+ }
+}
+
+_SOKOL_PRIVATE void* _sg_imgui_realloc(void* old_ptr, int old_size, int new_size) {
+ SOKOL_ASSERT((new_size > 0) && (new_size > old_size));
+ void* new_ptr = SOKOL_MALLOC(new_size);
+ SOKOL_ASSERT(new_ptr);
+ if (old_ptr) {
+ if (old_size > 0) {
+ memcpy(new_ptr, old_ptr, old_size);
+ }
+ _sg_imgui_free(old_ptr);
+ }
+ return new_ptr;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_strcpy(sg_imgui_str_t* dst, const char* src) {
+ SOKOL_ASSERT(dst);
+ if (src) {
+ #if defined(_MSC_VER)
+ strncpy_s(dst->buf, SG_IMGUI_STRBUF_LEN, src, (SG_IMGUI_STRBUF_LEN-1));
+ #else
+ strncpy(dst->buf, src, SG_IMGUI_STRBUF_LEN);
+ #endif
+ dst->buf[SG_IMGUI_STRBUF_LEN-1] = 0;
+ }
+ else {
+ memset(dst->buf, 0, SG_IMGUI_STRBUF_LEN);
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_make_str(const char* str) {
+ sg_imgui_str_t res;
+ _sg_imgui_strcpy(&res, str);
+ return res;
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_str_dup(const char* src) {
+ SOKOL_ASSERT(src);
+ int len = (int) strlen(src) + 1;
+ char* dst = (char*) _sg_imgui_alloc(len);
+ memcpy(dst, src, len);
+ return (const char*) dst;
+}
+
+_SOKOL_PRIVATE const uint8_t* _sg_imgui_bin_dup(const uint8_t* src, int num_bytes) {
+ SOKOL_ASSERT(src && (num_bytes > 0));
+ uint8_t* dst = (uint8_t*) _sg_imgui_alloc(num_bytes);
+ memcpy(dst, src, num_bytes);
+ return (const uint8_t*) dst;
+}
+
+/*--- STRING CONVERSION ------------------------------------------------------*/
+_SOKOL_PRIVATE const char* _sg_imgui_feature_string(sg_feature f) {
+ switch (f) {
+ case SG_FEATURE_INSTANCING: return "SG_FEATURE_INSTANCING";
+ case SG_FEATURE_TEXTURE_COMPRESSION_DXT: return "SG_FEATURE_TEXTURE_COMPRESSION_DXT";
+ case SG_FEATURE_TEXTURE_COMPRESSION_PVRTC: return "SG_FEATURE_TEXTURE_COMPRESSION_PVRTC";
+ case SG_FEATURE_TEXTURE_COMPRESSION_ATC: return "SG_FEATURE_TEXTURE_COMPRESSION_ATC";
+ case SG_FEATURE_TEXTURE_COMPRESSION_ETC2: return "SG_FEATURE_TEXTURE_COMPRESSION_ETC2";
+ case SG_FEATURE_TEXTURE_FLOAT: return "SG_FEATURE_TEXTURE_FLOAT";
+ case SG_FEATURE_TEXTURE_HALF_FLOAT: return "SG_FEATURE_TEXTURE_HALF_FLOAT";
+ case SG_FEATURE_ORIGIN_BOTTOM_LEFT: return "SG_FEATURE_ORIGIN_BOTTOM_LEFT";
+ case SG_FEATURE_ORIGIN_TOP_LEFT: return "SG_FEATURE_ORIGIN_TOP_LEFT";
+ case SG_FEATURE_MSAA_RENDER_TARGETS: return "SG_FEATURE_MSAA_RENDER_TARGETS";
+ case SG_FEATURE_PACKED_VERTEX_FORMAT_10_2: return "SG_FEATURE_PACKED_VERTEX_FORMAT_10_2";
+ case SG_FEATURE_MULTIPLE_RENDER_TARGET: return "SG_FEATURE_MULTIPLE_RENDER_TARGET";
+ case SG_FEATURE_IMAGETYPE_3D: return "SG_FEATURE_IMAGETYPE_3D";
+ case SG_FEATURE_IMAGETYPE_ARRAY: return "SG_FEATURE_IMAGETYPE_ARRAY";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_resourcestate_string(sg_resource_state s) {
+ switch (s) {
+ case SG_RESOURCESTATE_INITIAL: return "SG_RESOURCESTATE_INITIAL";
+ case SG_RESOURCESTATE_ALLOC: return "SG_RESOURCESTATE_ALLOC";
+ case SG_RESOURCESTATE_VALID: return "SG_RESOURCESTATE_VALID";
+ case SG_RESOURCESTATE_FAILED: return "SG_RESOURCESTATE_FAILED";
+ default: return "SG_RESOURCESTATE_INVALID";
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_resource_slot(const _sg_slot_t* slot) {
+ ImGui::Text("ResId: %08X", slot->id);
+ ImGui::Text("CtxId: %08X", slot->ctx_id);
+ ImGui::Text("State: %s", _sg_imgui_resourcestate_string(slot->state));
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_buffertype_string(sg_buffer_type t) {
+ switch (t) {
+ case SG_BUFFERTYPE_VERTEXBUFFER: return "SG_BUFFERTYPE_VERTEXBUFFER";
+ case SG_BUFFERTYPE_INDEXBUFFER: return "SG_BUFFERTYPE_INDEXBUFFER";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_usage_string(sg_usage u) {
+ switch (u) {
+ case SG_USAGE_IMMUTABLE: return "SG_USAGE_IMMUTABLE";
+ case SG_USAGE_DYNAMIC: return "SG_USAGE_DYNAMIC";
+ case SG_USAGE_STREAM: return "SG_USAGE_STREAM";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_imagetype_string(sg_image_type t) {
+ switch (t) {
+ case SG_IMAGETYPE_2D: return "SG_IMAGETYPE_2D";
+ case SG_IMAGETYPE_CUBE: return "SG_IMAGETYPE_CUBE";
+ case SG_IMAGETYPE_3D: return "SG_IMAGETYPE_3D";
+ case SG_IMAGETYPE_ARRAY: return "SG_IMAGETYPE_ARRAY";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_pixelformat_string(sg_pixel_format fmt) {
+ switch (fmt) {
+ case SG_PIXELFORMAT_NONE: return "SG_PIXELFORMAT_NONE";
+ case SG_PIXELFORMAT_RGBA8: return "SG_PIXELFORMAT_RGBA8";
+ case SG_PIXELFORMAT_RGB8: return "SG_PIXELFORMAT_RGB8";
+ case SG_PIXELFORMAT_RGBA4: return "SG_PIXELFORMAT_RGBA4";
+ case SG_PIXELFORMAT_R5G6B5: return "SG_PIXELFORMAT_R5G6B5";
+ case SG_PIXELFORMAT_R5G5B5A1: return "SG_PIXELFORMAT_R5G5B5A1";
+ case SG_PIXELFORMAT_R10G10B10A2: return "SG_PIXELFORMAT_R10G10B10A2";
+ case SG_PIXELFORMAT_RGBA32F: return "SG_PIXELFORMAT_RGBA32F";
+ case SG_PIXELFORMAT_RGBA16F: return "SG_PIXELFORMAT_RGBA16F";
+ case SG_PIXELFORMAT_R32F: return "SG_PIXELFORMAT_R32F";
+ case SG_PIXELFORMAT_R16F: return "SG_PIXELFORMAT_R16F";
+ case SG_PIXELFORMAT_L8: return "SG_PIXELFORMAT_L8";
+ case SG_PIXELFORMAT_DXT1: return "SG_PIXELFORMAT_DXT1";
+ case SG_PIXELFORMAT_DXT3: return "SG_PIXELFORMAT_DXT3";
+ case SG_PIXELFORMAT_DXT5: return "SG_PIXELFORMAT_DXT5";
+ case SG_PIXELFORMAT_DEPTH: return "SG_PIXELFORMAT_DEPTH";
+ case SG_PIXELFORMAT_DEPTHSTENCIL: return "SG_PIXELFORMAT_DEPTHSTENCIL";
+ case SG_PIXELFORMAT_PVRTC2_RGB: return "SG_PIXELFORMAT_PVRTC2_RGB";
+ case SG_PIXELFORMAT_PVRTC4_RGB: return "SG_PIXELFORMAT_PVRTC4_RGB";
+ case SG_PIXELFORMAT_PVRTC2_RGBA: return "SG_PIXELFORMAT_PVRTC2_RGBA";
+ case SG_PIXELFORMAT_PVRTC4_RGBA: return "SG_PIXELFORMAT_PVRTC4_RGBA";
+ case SG_PIXELFORMAT_ETC2_RGB8: return "SG_PIXELFORMAT_ETC2_RGB8";
+ case SG_PIXELFORMAT_ETC2_SRGB8: return "SG_PIXELFORMAT_ETC2_SRGB8";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_filter_string(sg_filter f) {
+ switch (f) {
+ case SG_FILTER_NEAREST: return "SG_FILTER_NEAREST";
+ case SG_FILTER_LINEAR: return "SG_FILTER_LINEAR";
+ case SG_FILTER_NEAREST_MIPMAP_NEAREST: return "SG_FILTER_NEAREST_MIPMAP_NEAREST";
+ case SG_FILTER_NEAREST_MIPMAP_LINEAR: return "SG_FILTER_NEAREST_MIPMAP_LINEAR";
+ case SG_FILTER_LINEAR_MIPMAP_NEAREST: return "SG_FILTER_LINEAR_MIPMAP_NEAREST";
+ case SG_FILTER_LINEAR_MIPMAP_LINEAR: return "SG_FILTER_LINEAR_MIPMAP_LINEAR";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_wrap_string(sg_wrap w) {
+ switch (w) {
+ case SG_WRAP_REPEAT: return "SG_WRAP_REPEAT";
+ case SG_WRAP_CLAMP_TO_EDGE: return "SG_WRAP_CLAMP_TO_EDGE";
+ case SG_WRAP_MIRRORED_REPEAT: return "SG_WRAP_MIRRORED_REPEAT";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_uniformtype_string(sg_uniform_type t) {
+ switch (t) {
+ case SG_UNIFORMTYPE_FLOAT: return "SG_UNIFORMTYPE_FLOAT";
+ case SG_UNIFORMTYPE_FLOAT2: return "SG_UNIFORMTYPE_FLOAT2";
+ case SG_UNIFORMTYPE_FLOAT3: return "SG_UNIFORMTYPE_FLOAT3";
+ case SG_UNIFORMTYPE_FLOAT4: return "SG_UNIFORMTYPE_FLOAT4";
+ case SG_UNIFORMTYPE_MAT4: return "SG_UNIFORMTYPE_MAT4";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_vertexstep_string(sg_vertex_step s) {
+ switch (s) {
+ case SG_VERTEXSTEP_PER_VERTEX: return "SG_VERTEXSTEP_PER_VERTEX";
+ case SG_VERTEXSTEP_PER_INSTANCE: return "SG_VERTEXSTEP_PER_INSTANCE";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_vertexformat_string(sg_vertex_format f) {
+ switch (f) {
+ case SG_VERTEXFORMAT_FLOAT: return "SG_VERTEXFORMAT_FLOAT";
+ case SG_VERTEXFORMAT_FLOAT2: return "SG_VERTEXFORMAT_FLOAT2";
+ case SG_VERTEXFORMAT_FLOAT3: return "SG_VERTEXFORMAT_FLOAT3";
+ case SG_VERTEXFORMAT_FLOAT4: return "SG_VERTEXFORMAT_FLOAT4";
+ case SG_VERTEXFORMAT_BYTE4: return "SG_VERTEXFORMAT_BYTE4";
+ case SG_VERTEXFORMAT_BYTE4N: return "SG_VERTEXFORMAT_BYTE4N";
+ case SG_VERTEXFORMAT_UBYTE4: return "SG_VERTEXFORMAT_UBYTE4";
+ case SG_VERTEXFORMAT_UBYTE4N: return "SG_VERTEXFORMAT_UBYTE4N";
+ case SG_VERTEXFORMAT_SHORT2: return "SG_VERTEXFORMAT_SHORT2";
+ case SG_VERTEXFORMAT_SHORT2N: return "SG_VERTEXFORMAT_SHORT2N";
+ case SG_VERTEXFORMAT_SHORT4: return "SG_VERTEXFORMAT_SHORT4";
+ case SG_VERTEXFORMAT_SHORT4N: return "SG_VERTEXFORMAT_SHORT4N";
+ case SG_VERTEXFORMAT_UINT10_N2: return "SG_VERTEXFORMAT_UINT10_N2";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_primitivetype_string(sg_primitive_type t) {
+ switch (t) {
+ case SG_PRIMITIVETYPE_POINTS: return "SG_PRIMITIVETYPE_POINTS";
+ case SG_PRIMITIVETYPE_LINES: return "SG_PRIMITIVETYPE_LINES";
+ case SG_PRIMITIVETYPE_LINE_STRIP: return "SG_PRIMITIVETYPE_LINE_STRIP";
+ case SG_PRIMITIVETYPE_TRIANGLES: return "SG_PRIMITIVETYPE_TRIANGLES";
+ case SG_PRIMITIVETYPE_TRIANGLE_STRIP: return "SG_PRIMITIVETYPE_TRIANGLE_STRIP";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_indextype_string(sg_index_type t) {
+ switch (t) {
+ case SG_INDEXTYPE_NONE: return "SG_INDEXTYPE_NONE";
+ case SG_INDEXTYPE_UINT16: return "SG_INDEXTYPE_UINT16";
+ case SG_INDEXTYPE_UINT32: return "SG_INDEXTYPE_UINT32";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_stencilop_string(sg_stencil_op op) {
+ switch (op) {
+ case SG_STENCILOP_KEEP: return "SG_STENCILOP_KEEP";
+ case SG_STENCILOP_ZERO: return "SG_STENCILOP_ZERO";
+ case SG_STENCILOP_REPLACE: return "SG_STENCILOP_REPLACE";
+ case SG_STENCILOP_INCR_CLAMP: return "SG_STENCILOP_INCR_CLAMP";
+ case SG_STENCILOP_DECR_CLAMP: return "SG_STENCILOP_DECR_CLAMP";
+ case SG_STENCILOP_INVERT: return "SG_STENCILOP_INVERT";
+ case SG_STENCILOP_INCR_WRAP: return "SG_STENCILOP_INCR_WRAP";
+ case SG_STENCILOP_DECR_WRAP: return "SG_STENCILOP_DECR_WRAP";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_comparefunc_string(sg_compare_func f) {
+ switch (f) {
+ case SG_COMPAREFUNC_NEVER: return "SG_COMPAREFUNC_NEVER";
+ case SG_COMPAREFUNC_LESS: return "SG_COMPAREFUNC_LESS";
+ case SG_COMPAREFUNC_EQUAL: return "SG_COMPAREFUNC_EQUAL";
+ case SG_COMPAREFUNC_LESS_EQUAL: return "SG_COMPAREFUNC_LESS_EQUAL";
+ case SG_COMPAREFUNC_GREATER: return "SG_COMPAREFUNC_GREATER";
+ case SG_COMPAREFUNC_NOT_EQUAL: return "SG_COMPAREFUNC_NOT_EQUAL";
+ case SG_COMPAREFUNC_GREATER_EQUAL: return "SG_COMPAREFUNC_GREATER_EQUAL";
+ case SG_COMPAREFUNC_ALWAYS: return "SG_COMPAREFUNC_ALWAYS";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_blendfactor_string(sg_blend_factor f) {
+ switch (f) {
+ case SG_BLENDFACTOR_ZERO: return "SG_BLENDFACTOR_ZERO";
+ case SG_BLENDFACTOR_ONE: return "SG_BLENDFACTOR_ONE";
+ case SG_BLENDFACTOR_SRC_COLOR: return "SG_BLENDFACTOR_SRC_COLOR";
+ case SG_BLENDFACTOR_ONE_MINUS_SRC_COLOR: return "SG_BLENDFACTOR_ONE_MINUS_SRC_COLOR";
+ case SG_BLENDFACTOR_SRC_ALPHA: return "SG_BLENDFACTOR_SRC_ALPHA";
+ case SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA: return "SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA";
+ case SG_BLENDFACTOR_DST_COLOR: return "SG_BLENDFACTOR_DST_COLOR";
+ case SG_BLENDFACTOR_ONE_MINUS_DST_COLOR: return "SG_BLENDFACTOR_ONE_MINUS_DST_COLOR";
+ case SG_BLENDFACTOR_DST_ALPHA: return "SG_BLENDFACTOR_DST_ALPHA";
+ case SG_BLENDFACTOR_ONE_MINUS_DST_ALPHA: return "SG_BLENDFACTOR_ONE_MINUS_DST_ALPHA";
+ case SG_BLENDFACTOR_SRC_ALPHA_SATURATED: return "SG_BLENDFACTOR_SRC_ALPHA_SATURATED";
+ case SG_BLENDFACTOR_BLEND_COLOR: return "SG_BLENDFACTOR_BLEND_COLOR";
+ case SG_BLENDFACTOR_ONE_MINUS_BLEND_COLOR: return "SG_BLENDFACTOR_ONE_MINUS_BLEND_COLOR";
+ case SG_BLENDFACTOR_BLEND_ALPHA: return "SG_BLENDFACTOR_BLEND_ALPHA";
+ case SG_BLENDFACTOR_ONE_MINUS_BLEND_ALPHA: return "SG_BLENDFACTOR_ONE_MINUS_BLEND_ALPHA";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_blendop_string(sg_blend_op op) {
+ switch (op) {
+ case SG_BLENDOP_ADD: return "SG_BLENDOP_ADD";
+ case SG_BLENDOP_SUBTRACT: return "SG_BLENDOP_SUBTRACT";
+ case SG_BLENDOP_REVERSE_SUBTRACT: return "SG_BLENDOP_REVERSE_SUBTRACT";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_colormask_string(uint8_t m) {
+ static const char* str[] = {
+ "NONE",
+ "R",
+ "G",
+ "RG",
+ "B",
+ "RB",
+ "GB",
+ "RGB",
+ "A",
+ "RA",
+ "GA",
+ "RGA",
+ "BA",
+ "RBA",
+ "GBA",
+ "RGBA",
+ };
+ return str[m & 0xF];
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_cullmode_string(sg_cull_mode cm) {
+ switch (cm) {
+ case SG_CULLMODE_NONE: return "SG_CULLMODE_NONE";
+ case SG_CULLMODE_FRONT: return "SG_CULLMODE_FRONT";
+ case SG_CULLMODE_BACK: return "SG_CULLMODE_BACK";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_facewinding_string(sg_face_winding fw) {
+ switch (fw) {
+ case SG_FACEWINDING_CCW: return "SG_FACEWINDING_CCW";
+ case SG_FACEWINDING_CW: return "SG_FACEWINDING_CW";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_shaderstage_string(sg_shader_stage stage) {
+ switch (stage) {
+ case SG_SHADERSTAGE_VS: return "SG_SHADERSTAGE_VS";
+ case SG_SHADERSTAGE_FS: return "SG_SHADERSTAGE_FS";
+ default: return "???";
+ }
+}
+
+_SOKOL_PRIVATE const char* _sg_imgui_bool_string(bool b) {
+ return b ? "true" : "false";
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_res_id_string(uint32_t res_id, const char* label) {
+ SOKOL_ASSERT(label);
+ sg_imgui_str_t res;
+ if (label[0]) {
+ snprintf(res.buf, sizeof(res.buf), "'%s'", label);
+ }
+ else {
+ snprintf(res.buf, sizeof(res.buf), "0x%08X", res_id);
+ }
+ return res;
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_buffer_id_string(sg_imgui_t* ctx, sg_buffer buf_id) {
+ if (buf_id.id != SG_INVALID_ID) {
+ const sg_imgui_buffer_t* buf_ui = &ctx->buffers.slots[_sg_slot_index(buf_id.id)];
+ return _sg_imgui_res_id_string(buf_id.id, buf_ui->label.buf);
+ }
+ else {
+ return _sg_imgui_make_str("<invalid>");
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_image_id_string(sg_imgui_t* ctx, sg_image img_id) {
+ if (img_id.id != SG_INVALID_ID) {
+ const sg_imgui_image_t* img_ui = &ctx->images.slots[_sg_slot_index(img_id.id)];
+ return _sg_imgui_res_id_string(img_id.id, img_ui->label.buf);
+ }
+ else {
+ return _sg_imgui_make_str("<invalid>");
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_shader_id_string(sg_imgui_t* ctx, sg_shader shd_id) {
+ if (shd_id.id != SG_INVALID_ID) {
+ const sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_slot_index(shd_id.id)];
+ return _sg_imgui_res_id_string(shd_id.id, shd_ui->label.buf);
+ }
+ else {
+ return _sg_imgui_make_str("<invalid>");
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_pipeline_id_string(sg_imgui_t* ctx, sg_pipeline pip_id) {
+ if (pip_id.id != SG_INVALID_ID) {
+ const sg_imgui_pipeline_t* pip_ui = &ctx->pipelines.slots[_sg_slot_index(pip_id.id)];
+ return _sg_imgui_res_id_string(pip_id.id, pip_ui->label.buf);
+ }
+ else {
+ return _sg_imgui_make_str("<invalid>");
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_pass_id_string(sg_imgui_t* ctx, sg_pass pass_id) {
+ if (pass_id.id != SG_INVALID_ID) {
+ const sg_imgui_pass_t* pass_ui = &ctx->passes.slots[_sg_slot_index(pass_id.id)];
+ return _sg_imgui_res_id_string(pass_id.id, pass_ui->label.buf);
+ }
+ else {
+ return _sg_imgui_make_str("<invalid>");
+ }
+}
+
+/*--- RESOURCE HELPERS -------------------------------------------------------*/
+_SOKOL_PRIVATE void _sg_imgui_buffer_created(sg_imgui_t* ctx, sg_buffer res_id, int slot_index, const sg_buffer_desc* desc) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->buffers.num_slots));
+ sg_imgui_buffer_t* buf = &ctx->buffers.slots[slot_index];
+ buf->res_id = res_id;
+ buf->desc = *desc;
+ buf->label = _sg_imgui_make_str(desc->label);
+
+ /* resolve default state */
+ buf->desc.type = _sg_def(buf->desc.type, SG_BUFFERTYPE_VERTEXBUFFER);
+ buf->desc.usage = _sg_def(buf->desc.usage, SG_USAGE_IMMUTABLE);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_buffer_destroyed(sg_imgui_t* ctx, int slot_index) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->buffers.num_slots));
+ sg_imgui_buffer_t* buf = &ctx->buffers.slots[slot_index];
+ buf->res_id.id = SG_INVALID_ID;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_image_created(sg_imgui_t* ctx, sg_image res_id, int slot_index, const sg_image_desc* desc) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->images.num_slots));
+ sg_imgui_image_t* img = &ctx->images.slots[slot_index];
+ img->res_id = res_id;
+ img->desc = *desc;
+ img->ui_scale = 1.0f;
+ img->label = _sg_imgui_make_str(desc->label);
+
+ /* resolve default state */
+ img->desc.type = _sg_def(img->desc.type, SG_IMAGETYPE_2D);
+ img->desc.depth = _sg_def(img->desc.depth, 1);
+ img->desc.num_mipmaps = _sg_def(img->desc.num_mipmaps, 1);
+ img->desc.usage = _sg_def(img->desc.usage, SG_USAGE_IMMUTABLE);
+ img->desc.pixel_format = _sg_def(img->desc.pixel_format, SG_PIXELFORMAT_RGBA8);
+ img->desc.sample_count = _sg_def(img->desc.sample_count, 1);
+ img->desc.min_filter = _sg_def(img->desc.min_filter, SG_FILTER_NEAREST);
+ img->desc.mag_filter = _sg_def(img->desc.mag_filter, SG_FILTER_NEAREST);
+ img->desc.wrap_u = _sg_def(img->desc.wrap_u, SG_WRAP_REPEAT);
+ img->desc.wrap_v = _sg_def(img->desc.wrap_v, SG_WRAP_REPEAT);
+ img->desc.wrap_w = _sg_def(img->desc.wrap_w, SG_WRAP_REPEAT);
+ img->desc.max_anisotropy = _sg_def(img->desc.max_anisotropy, 1);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_image_destroyed(sg_imgui_t* ctx, int slot_index) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->images.num_slots));
+ sg_imgui_image_t* img = &ctx->images.slots[slot_index];
+ img->res_id.id = SG_INVALID_ID;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_shader_created(sg_imgui_t* ctx, sg_shader res_id, int slot_index, const sg_shader_desc* desc) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->shaders.num_slots));
+ sg_imgui_shader_t* shd = &ctx->shaders.slots[slot_index];
+ shd->res_id = res_id;
+ shd->desc = *desc;
+ shd->label = _sg_imgui_make_str(desc->label);
+ if (shd->desc.vs.entry) {
+ shd->vs_entry = _sg_imgui_make_str(shd->desc.vs.entry);
+ shd->desc.vs.entry = shd->vs_entry.buf;
+ }
+ if (shd->desc.fs.entry) {
+ shd->fs_entry = _sg_imgui_make_str(shd->desc.fs.entry);
+ shd->desc.fs.entry = shd->fs_entry.buf;
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_UBS; i++) {
+ for (int j = 0; j < SG_MAX_UB_MEMBERS; j++) {
+ sg_shader_uniform_desc* ud = &shd->desc.vs.uniform_blocks[i].uniforms[j];
+ if (ud->name) {
+ shd->vs_uniform_name[i][j] = _sg_imgui_make_str(ud->name);
+ ud->name = shd->vs_uniform_name[i][j].buf;
+ }
+ }
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_UBS; i++) {
+ for (int j = 0; j < SG_MAX_UB_MEMBERS; j++) {
+ sg_shader_uniform_desc* ud = &shd->desc.fs.uniform_blocks[i].uniforms[j];
+ if (ud->name) {
+ shd->fs_uniform_name[i][j] = _sg_imgui_make_str(ud->name);
+ ud->name = shd->fs_uniform_name[i][j].buf;
+ }
+ }
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
+ if (shd->desc.vs.images[i].name) {
+ shd->vs_image_name[i] = _sg_imgui_make_str(shd->desc.vs.images[i].name);
+ shd->desc.vs.images[i].name = shd->vs_image_name[i].buf;
+ }
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
+ if (shd->desc.fs.images[i].name) {
+ shd->fs_image_name[i] = _sg_imgui_make_str(shd->desc.fs.images[i].name);
+ shd->desc.fs.images[i].name = shd->fs_image_name[i].buf;
+ }
+ }
+ if (shd->desc.vs.source) {
+ shd->desc.vs.source = _sg_imgui_str_dup(shd->desc.vs.source);
+ }
+ if (shd->desc.vs.byte_code) {
+ shd->desc.vs.byte_code = _sg_imgui_bin_dup(shd->desc.vs.byte_code, shd->desc.vs.byte_code_size);
+ }
+ if (shd->desc.fs.source) {
+ shd->desc.fs.source = _sg_imgui_str_dup(shd->desc.fs.source);
+ }
+ if (shd->desc.fs.byte_code) {
+ shd->desc.fs.byte_code = _sg_imgui_bin_dup(shd->desc.fs.byte_code, shd->desc.fs.byte_code_size);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_shader_destroyed(sg_imgui_t* ctx, int slot_index) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->shaders.num_slots));
+ sg_imgui_shader_t* shd = &ctx->shaders.slots[slot_index];
+ shd->res_id.id = SG_INVALID_ID;
+ if (shd->desc.vs.source) {
+ _sg_imgui_free((void*)shd->desc.vs.source);
+ shd->desc.vs.source = 0;
+ }
+ if (shd->desc.vs.byte_code) {
+ _sg_imgui_free((void*)shd->desc.vs.byte_code);
+ shd->desc.vs.byte_code = 0;
+ }
+ if (shd->desc.fs.source) {
+ _sg_imgui_free((void*)shd->desc.fs.source);
+ shd->desc.fs.source = 0;
+ }
+ if (shd->desc.fs.byte_code) {
+ _sg_imgui_free((void*)shd->desc.fs.byte_code);
+ shd->desc.fs.byte_code = 0;
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_pipeline_created(sg_imgui_t* ctx, sg_pipeline res_id, int slot_index, const sg_pipeline_desc* desc) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->pipelines.num_slots));
+ sg_imgui_pipeline_t* pip = &ctx->pipelines.slots[slot_index];
+ pip->res_id = res_id;
+ pip->label = _sg_imgui_make_str(desc->label);
+ pip->desc = *desc;
+
+ /* copy strings in vertex layout to persistent location */
+ for (int i = 0; i < SG_MAX_VERTEX_ATTRIBUTES; i++) {
+ sg_vertex_attr_desc* ad = &pip->desc.layout.attrs[i];
+ if (ad->name) {
+ pip->attr_name[i] = _sg_imgui_make_str(ad->name);
+ ad->name = pip->attr_name[i].buf;
+ }
+ if (ad->sem_name) {
+ pip->attr_sem_name[i] = _sg_imgui_make_str(ad->sem_name);
+ ad->sem_name = pip->attr_sem_name[i].buf;
+ }
+ }
+
+ /* need to resolve default values */
+ sg_depth_stencil_state* ds = &pip->desc.depth_stencil;
+ sg_stencil_state* dsf = &ds->stencil_front;
+ sg_stencil_state* dsb = &ds->stencil_back;
+ sg_blend_state* blend = &pip->desc.blend;
+ sg_rasterizer_state* rs = &pip->desc.rasterizer;
+ pip->desc.primitive_type = _sg_def(desc->primitive_type, SG_PRIMITIVETYPE_TRIANGLES);
+ pip->desc.index_type = _sg_def(desc->index_type, SG_INDEXTYPE_NONE);
+ dsf->fail_op = _sg_def(dsf->fail_op, SG_STENCILOP_KEEP);
+ dsf->depth_fail_op = _sg_def(dsf->depth_fail_op, SG_STENCILOP_KEEP);
+ dsf->pass_op = _sg_def(dsf->pass_op, SG_STENCILOP_KEEP);
+ dsf->compare_func = _sg_def(dsf->compare_func, SG_COMPAREFUNC_ALWAYS);
+ dsb->fail_op = _sg_def(dsb->fail_op, SG_STENCILOP_KEEP);
+ dsb->depth_fail_op = _sg_def(dsb->depth_fail_op, SG_STENCILOP_KEEP);
+ dsb->pass_op = _sg_def(dsb->pass_op, SG_STENCILOP_KEEP);
+ dsb->compare_func = _sg_def(dsb->compare_func, SG_COMPAREFUNC_ALWAYS);
+ ds->depth_compare_func = _sg_def(ds->depth_compare_func, SG_COMPAREFUNC_ALWAYS);
+ blend->src_factor_rgb = _sg_def(blend->src_factor_rgb, SG_BLENDFACTOR_ONE);
+ blend->dst_factor_rgb = _sg_def(blend->dst_factor_rgb, SG_BLENDFACTOR_ZERO);
+ blend->op_rgb = _sg_def(blend->op_rgb, SG_BLENDOP_ADD);
+ blend->src_factor_alpha = _sg_def(blend->src_factor_alpha, SG_BLENDFACTOR_ONE);
+ blend->dst_factor_alpha = _sg_def(blend->dst_factor_alpha, SG_BLENDFACTOR_ZERO);
+ blend->op_alpha = _sg_def(blend->op_alpha, SG_BLENDOP_ADD);
+ if (blend->color_write_mask == SG_COLORMASK_NONE) {
+ blend->color_write_mask = 0;
+ }
+ else {
+ blend->color_write_mask = (uint8_t) _sg_def((sg_color_mask)blend->color_write_mask, SG_COLORMASK_RGBA);
+ }
+ blend->color_attachment_count = _sg_def(blend->color_attachment_count, 1);
+ blend->color_format = _sg_def(blend->color_format, SG_PIXELFORMAT_RGBA8);
+ blend->depth_format = _sg_def(blend->depth_format, SG_PIXELFORMAT_DEPTHSTENCIL);
+ rs->cull_mode = _sg_def(rs->cull_mode, SG_CULLMODE_NONE);
+ rs->face_winding = _sg_def(rs->face_winding, SG_FACEWINDING_CW);
+ rs->sample_count = _sg_def(rs->sample_count, 1);
+
+ /* resolve vertex layout strides and offsets */
+ int auto_offset[SG_MAX_SHADERSTAGE_BUFFERS];
+ for (int layout_index = 0; layout_index < SG_MAX_SHADERSTAGE_BUFFERS; layout_index++) {
+ auto_offset[layout_index] = 0;
+ }
+ bool use_auto_offset = true;
+ for (int attr_index = 0; attr_index < SG_MAX_VERTEX_ATTRIBUTES; attr_index++) {
+ /* to use computed offsets, *all* attr offsets must be 0 */
+ if (pip->desc.layout.attrs[attr_index].offset != 0) {
+ use_auto_offset = false;
+ }
+ }
+ for (int attr_index = 0; attr_index < SG_MAX_VERTEX_ATTRIBUTES; attr_index++) {
+ sg_vertex_attr_desc* a_desc = &pip->desc.layout.attrs[attr_index];
+ if (a_desc->format == SG_VERTEXFORMAT_INVALID) {
+ break;
+ }
+ SOKOL_ASSERT((a_desc->buffer_index >= 0) && (a_desc->buffer_index < SG_MAX_SHADERSTAGE_BUFFERS));
+ if (use_auto_offset) {
+ a_desc->offset = auto_offset[a_desc->buffer_index];
+ }
+ auto_offset[a_desc->buffer_index] += _sg_vertexformat_bytesize(a_desc->format);
+ }
+ /* compute vertex strides if needed, and default-resolve step_func and rate */
+ for (int buf_index = 0; buf_index < SG_MAX_SHADERSTAGE_BUFFERS; buf_index++) {
+ sg_buffer_layout_desc* l_desc = &pip->desc.layout.buffers[buf_index];
+ l_desc->step_func = _sg_def(l_desc->step_func, SG_VERTEXSTEP_PER_VERTEX);
+ l_desc->step_rate = _sg_def(l_desc->step_rate, 1);
+ if (l_desc->stride == 0) {
+ l_desc->stride = auto_offset[buf_index];
+ }
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_pipeline_destroyed(sg_imgui_t* ctx, int slot_index) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->pipelines.num_slots));
+ sg_imgui_pipeline_t* pip = &ctx->pipelines.slots[slot_index];
+ pip->res_id.id = SG_INVALID_ID;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_pass_created(sg_imgui_t* ctx, sg_pass res_id, int slot_index, const sg_pass_desc* desc) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->passes.num_slots));
+ sg_imgui_pass_t* pass = &ctx->passes.slots[slot_index];
+ pass->res_id = res_id;
+ for (int i = 0; i < SG_MAX_COLOR_ATTACHMENTS; i++) {
+ pass->color_image_scale[i] = 0.25f;
+ }
+ pass->ds_image_scale = 0.25f;
+ pass->label = _sg_imgui_make_str(desc->label);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_pass_destroyed(sg_imgui_t* ctx, int slot_index) {
+ SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->passes.num_slots));
+ sg_imgui_pass_t* pass = &ctx->passes.slots[slot_index];
+ pass->res_id.id = SG_INVALID_ID;
+}
+
+/*--- COMMAND CAPTURING ------------------------------------------------------*/
+_SOKOL_PRIVATE void _sg_imgui_capture_init(sg_imgui_t* ctx) {
+ const int ubuf_initial_size = 256 * 1024;
+ for (int i = 0; i < 2; i++) {
+ sg_imgui_capture_bucket_t* bucket = &ctx->capture.bucket[i];
+ bucket->ubuf_size = ubuf_initial_size;
+ bucket->ubuf = (uint8_t*) _sg_imgui_alloc(bucket->ubuf_size);
+ SOKOL_ASSERT(bucket->ubuf);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_capture_discard(sg_imgui_t* ctx) {
+ for (int i = 0; i < 2; i++) {
+ sg_imgui_capture_bucket_t* bucket = &ctx->capture.bucket[i];
+ SOKOL_ASSERT(bucket->ubuf);
+ _sg_imgui_free(bucket->ubuf);
+ bucket->ubuf = 0;
+ }
+}
+
+_SOKOL_PRIVATE sg_imgui_capture_bucket_t* _sg_imgui_capture_get_write_bucket(sg_imgui_t* ctx) {
+ return &ctx->capture.bucket[ctx->capture.bucket_index & 1];
+}
+
+_SOKOL_PRIVATE sg_imgui_capture_bucket_t* _sg_imgui_capture_get_read_bucket(sg_imgui_t* ctx) {
+ return &ctx->capture.bucket[(ctx->capture.bucket_index + 1) & 1];
+}
+
+_SOKOL_PRIVATE void _sg_imgui_capture_next_frame(sg_imgui_t* ctx) {
+ ctx->capture.bucket_index = (ctx->capture.bucket_index + 1) & 1;
+ sg_imgui_capture_bucket_t* bucket = &ctx->capture.bucket[ctx->capture.bucket_index];
+ bucket->num_items = 0;
+ bucket->ubuf_pos = 0;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_capture_grow_ubuf(sg_imgui_t* ctx, uint32_t required_size) {
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_write_bucket(ctx);
+ SOKOL_ASSERT(required_size > bucket->ubuf_size);
+ int old_size = bucket->ubuf_size;
+ int new_size = required_size + (required_size>>1); /* allocate a bit ahead */
+ bucket->ubuf_size = new_size;
+ bucket->ubuf = (uint8_t*) _sg_imgui_realloc(bucket->ubuf, old_size, new_size);
+}
+
+_SOKOL_PRIVATE sg_imgui_capture_item_t* _sg_imgui_capture_next_write_item(sg_imgui_t* ctx) {
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_write_bucket(ctx);
+ if (bucket->num_items < SG_IMGUI_MAX_FRAMECAPTURE_ITEMS) {
+ sg_imgui_capture_item_t* item = &bucket->items[bucket->num_items++];
+ return item;
+ }
+ else {
+ return 0;
+ }
+}
+
+_SOKOL_PRIVATE uint32_t _sg_imgui_capture_num_read_items(sg_imgui_t* ctx) {
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_read_bucket(ctx);
+ return bucket->num_items;
+}
+
+_SOKOL_PRIVATE sg_imgui_capture_item_t* _sg_imgui_capture_read_item_at(sg_imgui_t* ctx, uint32_t index) {
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_read_bucket(ctx);
+ SOKOL_ASSERT(index < bucket->num_items);
+ return &bucket->items[index];
+}
+
+_SOKOL_PRIVATE uint32_t _sg_imgui_capture_uniforms(sg_imgui_t* ctx, const void* data, int num_bytes) {
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_write_bucket(ctx);
+ const uint32_t required_size = bucket->ubuf_pos + num_bytes;
+ if (required_size > bucket->ubuf_size) {
+ _sg_imgui_capture_grow_ubuf(ctx, required_size);
+ }
+ SOKOL_ASSERT(required_size <= bucket->ubuf_size);
+ memcpy(bucket->ubuf + bucket->ubuf_pos, data, num_bytes);
+ const uint32_t pos = bucket->ubuf_pos;
+ bucket->ubuf_pos += num_bytes;
+ SOKOL_ASSERT(bucket->ubuf_pos <= bucket->ubuf_size);
+ return pos;
+}
+
+_SOKOL_PRIVATE sg_imgui_str_t _sg_imgui_capture_item_string(sg_imgui_t* ctx, int index, const sg_imgui_capture_item_t* item) {
+ sg_imgui_str_t str = _sg_imgui_make_str(0);
+ sg_imgui_str_t res_id = _sg_imgui_make_str(0);
+ const int len = sizeof(str.buf);
+ switch (item->cmd) {
+ case SG_IMGUI_CMD_QUERY_FEATURE:
+ snprintf(str.buf, len, "%d: sg_query_feature(feature=%s) => %s",
+ index,
+ _sg_imgui_feature_string(item->args.query_feature.feature),
+ _sg_imgui_bool_string(item->args.query_feature.result));
+ break;
+
+ case SG_IMGUI_CMD_RESET_STATE_CACHE:
+ snprintf(str.buf, len, "%d: sg_reset_state_cache()", index);
+ break;
+
+ case SG_IMGUI_CMD_MAKE_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.make_buffer.result);
+ snprintf(str.buf, len, "%d: sg_make_buffer(desc=..) => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_MAKE_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.make_image.result);
+ snprintf(str.buf, len, "%d: sg_make_image(desc=..) => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_MAKE_SHADER:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.make_shader.result);
+ snprintf(str.buf, len, "%d: sg_make_shader(desc=..) => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_MAKE_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.make_pipeline.result);
+ snprintf(str.buf, len, "%d: sg_make_pipeline(desc=..) => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_MAKE_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.make_pass.result);
+ snprintf(str.buf, len, "%d: sg_make_pass(desc=..) => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_DESTROY_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.destroy_buffer.buffer);
+ snprintf(str.buf, len, "%d: sg_destroy_buffer(buf=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_DESTROY_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.destroy_image.image);
+ snprintf(str.buf, len, "%d: sg_destroy_image(img=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_DESTROY_SHADER:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.destroy_shader.shader);
+ snprintf(str.buf, len, "%d: sg_destroy_shader(shd=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_DESTROY_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.destroy_pipeline.pipeline);
+ snprintf(str.buf, len, "%d: sg_destroy_pipeline(pip=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_DESTROY_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.destroy_pass.pass);
+ snprintf(str.buf, len, "%d: sg_destroy_pass(pass=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_UPDATE_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.update_buffer.buffer);
+ snprintf(str.buf, len, "%d: sg_update_buffer(buf=%s, data_ptr=.., data_size=%d)",
+ index, res_id.buf,
+ item->args.update_buffer.data_size);
+ break;
+
+ case SG_IMGUI_CMD_UPDATE_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.update_image.image);
+ snprintf(str.buf, len, "%d: sg_update_image(img=%s, data=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_APPEND_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.append_buffer.buffer);
+ snprintf(str.buf, len, "%d: sg_append_buffer(buf=%s, data_ptr=.., data_size=%d) => %d",
+ index, res_id.buf,
+ item->args.append_buffer.data_size,
+ item->args.append_buffer.result);
+ break;
+
+ case SG_IMGUI_CMD_QUERY_BUFFER_OVERFLOW:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.query_buffer_overflow.buffer);
+ snprintf(str.buf, len, "%d: sg_query_buffer_overflow(buf=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_bool_string(item->args.query_buffer_overflow.result));
+ break;
+
+ case SG_IMGUI_CMD_QUERY_BUFFER_STATE:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.query_buffer_state.buffer);
+ snprintf(str.buf, len, "%d: sg_query_buffer_state(buf=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_resourcestate_string(item->args.query_buffer_state.result));
+ break;
+
+ case SG_IMGUI_CMD_QUERY_IMAGE_STATE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.query_image_state.image);
+ snprintf(str.buf, len, "%d: sg_query_image_state(img=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_resourcestate_string(item->args.query_image_state.result));
+ break;
+
+ case SG_IMGUI_CMD_QUERY_SHADER_STATE:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.query_shader_state.shader);
+ snprintf(str.buf, len, "%d: sg_query_shader_state(shd=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_resourcestate_string(item->args.query_shader_state.result));
+ break;
+
+ case SG_IMGUI_CMD_QUERY_PIPELINE_STATE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.query_pipeline_state.pipeline);
+ snprintf(str.buf, len, "%d: sg_query_pipeline_state(pip=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_resourcestate_string(item->args.query_pipeline_state.result));
+ break;
+
+ case SG_IMGUI_CMD_QUERY_PASS_STATE:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.query_pass_state.pass);
+ snprintf(str.buf, len, "%d: sg_query_pass_state(pass=%s) => %s",
+ index, res_id.buf,
+ _sg_imgui_resourcestate_string(item->args.query_pass_state.result));
+ break;
+
+ case SG_IMGUI_CMD_BEGIN_DEFAULT_PASS:
+ snprintf(str.buf, len, "%d: sg_begin_default_pass(pass_action=.., width=%d, height=%d)",
+ index,
+ item->args.begin_default_pass.width,
+ item->args.begin_default_pass.height);
+ break;
+
+ case SG_IMGUI_CMD_BEGIN_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.begin_pass.pass);
+ snprintf(str.buf, len, "%d: sg_begin_pass(pass=%s, pass_action=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_APPLY_VIEWPORT:
+ snprintf(str.buf, len, "%d: sg_apply_viewport(x=%d, y=%d, width=%d, height=%d, origin_top_left=%s)",
+ index,
+ item->args.apply_viewport.x,
+ item->args.apply_viewport.y,
+ item->args.apply_viewport.width,
+ item->args.apply_viewport.height,
+ _sg_imgui_bool_string(item->args.apply_viewport.origin_top_left));
+ break;
+
+ case SG_IMGUI_CMD_APPLY_SCISSOR_RECT:
+ snprintf(str.buf, len, "%d: sg_apply_scissor_rect(x=%d, y=%d, width=%d, height=%d, origin_top_left=%s)",
+ index,
+ item->args.apply_scissor_rect.x,
+ item->args.apply_scissor_rect.y,
+ item->args.apply_scissor_rect.width,
+ item->args.apply_scissor_rect.height,
+ _sg_imgui_bool_string(item->args.apply_scissor_rect.origin_top_left));
+ break;
+
+ case SG_IMGUI_CMD_APPLY_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.apply_pipeline.pipeline);
+ snprintf(str.buf, len, "%d: sg_apply_pipeline(pip=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_APPLY_BINDINGS:
+ snprintf(str.buf, len, "%d: sg_apply_bindings(bindings=..)", index);
+ break;
+
+ case SG_IMGUI_CMD_APPLY_UNIFORMS:
+ snprintf(str.buf, len, "%d: sg_apply_uniforms(stage=%s, ub_index=%d, data=.., num_bytes=%d)",
+ index,
+ _sg_imgui_shaderstage_string(item->args.apply_uniforms.stage),
+ item->args.apply_uniforms.ub_index,
+ item->args.apply_uniforms.num_bytes);
+ break;
+
+ case SG_IMGUI_CMD_DRAW:
+ snprintf(str.buf, len, "%d: sg_draw(base_element=%d, num_elements=%d, num_instances=%d)",
+ index,
+ item->args.draw.base_element,
+ item->args.draw.num_elements,
+ item->args.draw.num_instances);
+ break;
+
+ case SG_IMGUI_CMD_END_PASS:
+ snprintf(str.buf, len, "%d: sg_end_pass()", index);
+ break;
+
+ case SG_IMGUI_CMD_COMMIT:
+ snprintf(str.buf, len, "%d: sg_commit()", index);
+ break;
+
+ case SG_IMGUI_CMD_ALLOC_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.alloc_buffer.result);
+ snprintf(str.buf, len, "%d: sg_alloc_buffer() => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_ALLOC_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.alloc_image.result);
+ snprintf(str.buf, len, "%d: sg_alloc_image() => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_ALLOC_SHADER:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.alloc_shader.result);
+ snprintf(str.buf, len, "%d: sg_alloc_shader() => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_ALLOC_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.alloc_pipeline.result);
+ snprintf(str.buf, len, "%d: sg_alloc_pipeline() => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_ALLOC_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.alloc_pass.result);
+ snprintf(str.buf, len, "%d: sg_alloc_pass() => %s", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_INIT_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.init_buffer.buffer);
+ snprintf(str.buf, len, "%d: sg_init_buffer(buf=%s, desc=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_INIT_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.init_image.image);
+ snprintf(str.buf, len, "%d: sg_init_image(img=%s, desc=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_INIT_SHADER:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.init_shader.shader);
+ snprintf(str.buf, len, "%d: sg_init_shader(shd=%s, desc=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_INIT_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.init_pipeline.pipeline);
+ snprintf(str.buf, len, "%d: sg_init_pipeline(pip=%s, desc=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_INIT_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.init_pass.pass);
+ snprintf(str.buf, len, "%d: sg_init_pass(pass=%s, desc=..)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_FAIL_BUFFER:
+ res_id = _sg_imgui_buffer_id_string(ctx, item->args.fail_buffer.buffer);
+ snprintf(str.buf, len, "%d: sg_fail_buffer(buf=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_FAIL_IMAGE:
+ res_id = _sg_imgui_image_id_string(ctx, item->args.fail_image.image);
+ snprintf(str.buf, len, "%d: sg_fail_image(img=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_FAIL_SHADER:
+ res_id = _sg_imgui_shader_id_string(ctx, item->args.fail_shader.shader);
+ snprintf(str.buf, len, "%d: sg_fail_shader(shd=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_FAIL_PIPELINE:
+ res_id = _sg_imgui_pipeline_id_string(ctx, item->args.fail_pipeline.pipeline);
+ snprintf(str.buf, len, "%d: sg_fail_pipeline(shd=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_FAIL_PASS:
+ res_id = _sg_imgui_pass_id_string(ctx, item->args.fail_pass.pass);
+ snprintf(str.buf, len, "%d: sg_fail_pass(pass=%s)", index, res_id.buf);
+ break;
+
+ case SG_IMGUI_CMD_PUSH_DEBUG_GROUP:
+ snprintf(str.buf, len, "%d: sg_push_debug_group(name=%s)", index,
+ item->args.push_debug_group.name.buf);
+ break;
+
+ case SG_IMGUI_CMD_POP_DEBUG_GROUP:
+ snprintf(str.buf, len, "%d: sg_pop_debug_group()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_BUFFER_POOL_EXHAUSTED:
+ snprintf(str.buf, len, "%d: sg_err_buffer_pool_exhausted()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_IMAGE_POOL_EXHAUSTED:
+ snprintf(str.buf, len, "%d: sg_err_image_pool_exhausted()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_SHADER_POOL_EXHAUSTED:
+ snprintf(str.buf, len, "%d: sg_err_shader_pool_exhausted()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_PIPELINE_POOL_EXHAUSTED:
+ snprintf(str.buf, len, "%d: sg_err_pipeline_pool_exhausted()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_PASS_POOL_EXHAUSTED:
+ snprintf(str.buf, len, "%d: sg_err_pass_pool_exhausted()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_CONTEXT_MISMATCH:
+ snprintf(str.buf, len, "%d: sg_err_context_mismatch()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_PASS_INVALID:
+ snprintf(str.buf, len, "%d: sg_err_pass_invalid()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_DRAW_INVALID:
+ snprintf(str.buf, len, "%d: sg_err_draw_invalid()", index);
+ break;
+
+ case SG_IMGUI_CMD_ERR_BINDINGS_INVALID:
+ snprintf(str.buf, len, "%d: sg_err_bindings_invalid()", index);
+ break;
+
+ default:
+ snprintf(str.buf, len, "%d: ???", index);
+ break;
+ }
+ str.buf[len-1] = 0;
+ return str;
+}
+
+/*--- CAPTURE CALLBACKS ------------------------------------------------------*/
+_SOKOL_PRIVATE void _sg_imgui_query_feature(sg_feature feature, bool result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_FEATURE;
+ item->color = _SG_IMGUI_COLOR_OTHER;
+ item->args.query_feature.feature = feature;
+ item->args.query_feature.result = result;
+ }
+ if (ctx->hooks.query_feature) {
+ ctx->hooks.query_feature(feature, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_reset_state_cache(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_RESET_STATE_CACHE;
+ item->color = _SG_IMGUI_COLOR_OTHER;
+ }
+ if (ctx->hooks.reset_state_cache) {
+ ctx->hooks.reset_state_cache(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_make_buffer(const sg_buffer_desc* desc, sg_buffer buf_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_MAKE_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.make_buffer.result = buf_id;
+ }
+ if (ctx->hooks.make_buffer) {
+ ctx->hooks.make_buffer(desc, buf_id, ctx->hooks.user_data);
+ }
+ if (buf_id.id != SG_INVALID_ID) {
+ _sg_imgui_buffer_created(ctx, buf_id, _sg_slot_index(buf_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_make_image(const sg_image_desc* desc, sg_image img_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_MAKE_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.make_image.result = img_id;
+ }
+ if (ctx->hooks.make_image) {
+ ctx->hooks.make_image(desc, img_id, ctx->hooks.user_data);
+ }
+ if (img_id.id != SG_INVALID_ID) {
+ _sg_imgui_image_created(ctx, img_id, _sg_slot_index(img_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_make_shader(const sg_shader_desc* desc, sg_shader shd_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_MAKE_SHADER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.make_shader.result = shd_id;
+ }
+ if (ctx->hooks.make_shader) {
+ ctx->hooks.make_shader(desc, shd_id, ctx->hooks.user_data);
+ }
+ if (shd_id.id != SG_INVALID_ID) {
+ _sg_imgui_shader_created(ctx, shd_id, _sg_slot_index(shd_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_make_pipeline(const sg_pipeline_desc* desc, sg_pipeline pip_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_MAKE_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.make_pipeline.result = pip_id;
+ }
+ if (ctx->hooks.make_pipeline) {
+ ctx->hooks.make_pipeline(desc, pip_id, ctx->hooks.user_data);
+ }
+ if (pip_id.id != SG_INVALID_ID) {
+ _sg_imgui_pipeline_created(ctx, pip_id, _sg_slot_index(pip_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_make_pass(const sg_pass_desc* desc, sg_pass pass_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_MAKE_PASS;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.make_pass.result = pass_id;
+ }
+ if (ctx->hooks.make_pass) {
+ ctx->hooks.make_pass(desc, pass_id, ctx->hooks.user_data);
+ }
+ if (pass_id.id != SG_INVALID_ID) {
+ _sg_imgui_pass_created(ctx, pass_id, _sg_slot_index(pass_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_destroy_buffer(sg_buffer buf, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DESTROY_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.destroy_buffer.buffer = buf;
+ }
+ if (ctx->hooks.destroy_buffer) {
+ ctx->hooks.destroy_buffer(buf, ctx->hooks.user_data);
+ }
+ if (buf.id != SG_INVALID_ID) {
+ _sg_imgui_buffer_destroyed(ctx, _sg_slot_index(buf.id));
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_destroy_image(sg_image img, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DESTROY_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.destroy_image.image = img;
+ }
+ if (ctx->hooks.destroy_image) {
+ ctx->hooks.destroy_image(img, ctx->hooks.user_data);
+ }
+ if (img.id != SG_INVALID_ID) {
+ _sg_imgui_image_destroyed(ctx, _sg_slot_index(img.id));
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_destroy_shader(sg_shader shd, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DESTROY_SHADER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.destroy_shader.shader = shd;
+ }
+ if (ctx->hooks.destroy_shader) {
+ ctx->hooks.destroy_shader(shd, ctx->hooks.user_data);
+ }
+ if (shd.id != SG_INVALID_ID) {
+ _sg_imgui_shader_destroyed(ctx, _sg_slot_index(shd.id));
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_destroy_pipeline(sg_pipeline pip, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DESTROY_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.destroy_pipeline.pipeline = pip;
+ }
+ if (ctx->hooks.destroy_pipeline) {
+ ctx->hooks.destroy_pipeline(pip, ctx->hooks.user_data);
+ }
+ if (pip.id != SG_INVALID_ID) {
+ _sg_imgui_pipeline_destroyed(ctx, _sg_slot_index(pip.id));
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_destroy_pass(sg_pass pass, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DESTROY_PASS;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.destroy_pass.pass = pass;
+ }
+ if (ctx->hooks.destroy_pass) {
+ ctx->hooks.destroy_pass(pass, ctx->hooks.user_data);
+ }
+ if (pass.id != SG_INVALID_ID) {
+ _sg_imgui_pass_destroyed(ctx, _sg_slot_index(pass.id));
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_update_buffer(sg_buffer buf, const void* data_ptr, int data_size, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_UPDATE_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.update_buffer.buffer = buf;
+ item->args.update_buffer.data_size = data_size;
+ }
+ if (ctx->hooks.update_buffer) {
+ ctx->hooks.update_buffer(buf, data_ptr, data_size, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_update_image(sg_image img, const sg_image_content* data, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_UPDATE_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.update_image.image = img;
+ }
+ if (ctx->hooks.update_image) {
+ ctx->hooks.update_image(img, data, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_append_buffer(sg_buffer buf, const void* data_ptr, int data_size, int result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_APPEND_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.append_buffer.buffer = buf;
+ item->args.append_buffer.data_size = data_size;
+ item->args.append_buffer.result = result;
+ }
+ if (ctx->hooks.append_buffer) {
+ ctx->hooks.append_buffer(buf, data_ptr, data_size, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_buffer_overflow(sg_buffer buf, bool result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_BUFFER_OVERFLOW;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_buffer_overflow.buffer = buf;
+ item->args.query_buffer_overflow.result = result;
+ }
+ if (ctx->hooks.query_buffer_overflow) {
+ ctx->hooks.query_buffer_overflow(buf, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_buffer_state(sg_buffer buf, sg_resource_state result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_BUFFER_STATE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_buffer_state.buffer = buf;
+ item->args.query_buffer_state.result = result;
+ }
+ if (ctx->hooks.query_buffer_state) {
+ ctx->hooks.query_buffer_state(buf, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_image_state(sg_image img, sg_resource_state result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_IMAGE_STATE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_image_state.image = img;
+ item->args.query_image_state.result = result;
+ }
+ if (ctx->hooks.query_image_state) {
+ ctx->hooks.query_image_state(img, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_shader_state(sg_shader shd, sg_resource_state result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_SHADER_STATE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_shader_state.shader = shd;
+ item->args.query_shader_state.result = result;
+ }
+ if (ctx->hooks.query_shader_state) {
+ ctx->hooks.query_shader_state(shd, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_pipeline_state(sg_pipeline pip, sg_resource_state result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_PIPELINE_STATE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_pipeline_state.pipeline = pip;
+ item->args.query_pipeline_state.result = result;
+ }
+ if (ctx->hooks.query_pipeline_state) {
+ ctx->hooks.query_pipeline_state(pip, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_query_pass_state(sg_pass pass, sg_resource_state result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_QUERY_PASS_STATE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.query_pass_state.pass = pass;
+ item->args.query_pass_state.result = result;
+ }
+ if (ctx->hooks.query_pass_state) {
+ ctx->hooks.query_pass_state(pass, result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_begin_default_pass(const sg_pass_action* pass_action, int width, int height, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ SOKOL_ASSERT(pass_action);
+ item->cmd = SG_IMGUI_CMD_BEGIN_DEFAULT_PASS;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.begin_default_pass.action = *pass_action;
+ item->args.begin_default_pass.width = width;
+ item->args.begin_default_pass.height = height;
+ }
+ if (ctx->hooks.begin_default_pass) {
+ ctx->hooks.begin_default_pass(pass_action, width, height, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_begin_pass(sg_pass pass, const sg_pass_action* pass_action, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ SOKOL_ASSERT(pass_action);
+ item->cmd = SG_IMGUI_CMD_BEGIN_PASS;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.begin_pass.pass = pass;
+ item->args.begin_pass.action = *pass_action;
+ }
+ if (ctx->hooks.begin_pass) {
+ ctx->hooks.begin_pass(pass, pass_action, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_apply_viewport(int x, int y, int width, int height, bool origin_top_left, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_APPLY_VIEWPORT;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.apply_viewport.x = x;
+ item->args.apply_viewport.y = y;
+ item->args.apply_viewport.width = width;
+ item->args.apply_viewport.height = height;
+ item->args.apply_viewport.origin_top_left = origin_top_left;
+ }
+ if (ctx->hooks.apply_viewport) {
+ ctx->hooks.apply_viewport(x, y, width, height, origin_top_left, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_apply_scissor_rect(int x, int y, int width, int height, bool origin_top_left, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_APPLY_SCISSOR_RECT;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.apply_scissor_rect.x = x;
+ item->args.apply_scissor_rect.y = y;
+ item->args.apply_scissor_rect.width = width;
+ item->args.apply_scissor_rect.height = height;
+ item->args.apply_scissor_rect.origin_top_left = origin_top_left;
+ }
+ if (ctx->hooks.apply_scissor_rect) {
+ ctx->hooks.apply_scissor_rect(x, y, width, height, origin_top_left, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_apply_pipeline(sg_pipeline pip, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_APPLY_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.apply_pipeline.pipeline = pip;
+ }
+ if (ctx->hooks.apply_pipeline) {
+ ctx->hooks.apply_pipeline(pip, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_apply_bindings(const sg_bindings* bindings, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ SOKOL_ASSERT(bindings);
+ item->cmd = SG_IMGUI_CMD_APPLY_BINDINGS;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.apply_bindings.bindings = *bindings;
+ }
+ if (ctx->hooks.apply_bindings) {
+ ctx->hooks.apply_bindings(bindings, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_apply_uniforms(sg_shader_stage stage, int ub_index, const void* data, int num_bytes, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_APPLY_UNIFORMS;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ sg_imgui_args_apply_uniforms_t* args = &item->args.apply_uniforms;
+ args->stage = stage;
+ args->ub_index = ub_index;
+ args->data = data;
+ args->num_bytes = num_bytes;
+ args->pipeline = _sg.cur_pipeline;
+ args->ubuf_pos = _sg_imgui_capture_uniforms(ctx, data, num_bytes);
+ }
+ if (ctx->hooks.apply_uniforms) {
+ ctx->hooks.apply_uniforms(stage, ub_index, data, num_bytes, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw(int base_element, int num_elements, int num_instances, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_DRAW;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ item->args.draw.base_element = base_element;
+ item->args.draw.num_elements = num_elements;
+ item->args.draw.num_instances = num_instances;
+ }
+ if (ctx->hooks.draw) {
+ ctx->hooks.draw(base_element, num_elements, num_instances, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_end_pass(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_END_PASS;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ }
+ if (ctx->hooks.end_pass) {
+ ctx->hooks.end_pass(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_commit(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_COMMIT;
+ item->color = _SG_IMGUI_COLOR_DRAW;
+ }
+ _sg_imgui_capture_next_frame(ctx);
+ if (ctx->hooks.commit) {
+ ctx->hooks.commit(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_alloc_buffer(sg_buffer result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ALLOC_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.alloc_buffer.result = result;
+ }
+ if (ctx->hooks.alloc_buffer) {
+ ctx->hooks.alloc_buffer(result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_alloc_image(sg_image result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ALLOC_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.alloc_image.result = result;
+ }
+ if (ctx->hooks.alloc_image) {
+ ctx->hooks.alloc_image(result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_alloc_shader(sg_shader result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ALLOC_SHADER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.alloc_shader.result = result;
+ }
+ if (ctx->hooks.alloc_shader) {
+ ctx->hooks.alloc_shader(result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_alloc_pipeline(sg_pipeline result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ALLOC_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.alloc_pipeline.result = result;
+ }
+ if (ctx->hooks.alloc_pipeline) {
+ ctx->hooks.alloc_pipeline(result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_alloc_pass(sg_pass result, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ALLOC_PASS;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.alloc_pass.result = result;
+ }
+ if (ctx->hooks.alloc_pass) {
+ ctx->hooks.alloc_pass(result, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_init_buffer(sg_buffer buf_id, const sg_buffer_desc* desc, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_INIT_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.init_buffer.buffer = buf_id;
+ }
+ if (ctx->hooks.init_buffer) {
+ ctx->hooks.init_buffer(buf_id, desc, ctx->hooks.user_data);
+ }
+ if (buf_id.id != SG_INVALID_ID) {
+ _sg_imgui_buffer_created(ctx, buf_id, _sg_slot_index(buf_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_init_image(sg_image img_id, const sg_image_desc* desc, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_INIT_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.init_image.image = img_id;
+ }
+ if (ctx->hooks.init_image) {
+ ctx->hooks.init_image(img_id, desc, ctx->hooks.user_data);
+ }
+ if (img_id.id != SG_INVALID_ID) {
+ _sg_imgui_image_created(ctx, img_id, _sg_slot_index(img_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_init_shader(sg_shader shd_id, const sg_shader_desc* desc, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_INIT_SHADER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.init_shader.shader = shd_id;
+ }
+ if (ctx->hooks.init_shader) {
+ ctx->hooks.init_shader(shd_id, desc, ctx->hooks.user_data);
+ }
+ if (shd_id.id != SG_INVALID_ID) {
+ _sg_imgui_shader_created(ctx, shd_id, _sg_slot_index(shd_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_init_pipeline(sg_pipeline pip_id, const sg_pipeline_desc* desc, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_INIT_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.init_pipeline.pipeline = pip_id;
+ }
+ if (ctx->hooks.init_pipeline) {
+ ctx->hooks.init_pipeline(pip_id, desc, ctx->hooks.user_data);
+ }
+ if (pip_id.id != SG_INVALID_ID) {
+ _sg_imgui_pipeline_created(ctx, pip_id, _sg_slot_index(pip_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_init_pass(sg_pass pass_id, const sg_pass_desc* desc, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_INIT_PASS;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.init_pass.pass = pass_id;
+ }
+ if (ctx->hooks.init_pass) {
+ ctx->hooks.init_pass(pass_id, desc, ctx->hooks.user_data);
+ }
+ if (pass_id.id != SG_INVALID_ID) {
+ _sg_imgui_pass_created(ctx, pass_id, _sg_slot_index(pass_id.id), desc);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_fail_buffer(sg_buffer buf_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_FAIL_BUFFER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.fail_buffer.buffer = buf_id;
+ }
+ if (ctx->hooks.fail_buffer) {
+ ctx->hooks.fail_buffer(buf_id, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_fail_image(sg_image img_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_FAIL_IMAGE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.fail_image.image = img_id;
+ }
+ if (ctx->hooks.fail_image) {
+ ctx->hooks.fail_image(img_id, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_fail_shader(sg_shader shd_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_FAIL_SHADER;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.fail_shader.shader = shd_id;
+ }
+ if (ctx->hooks.fail_shader) {
+ ctx->hooks.fail_shader(shd_id, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_fail_pipeline(sg_pipeline pip_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_FAIL_PIPELINE;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.fail_pipeline.pipeline = pip_id;
+ }
+ if (ctx->hooks.fail_pipeline) {
+ ctx->hooks.fail_pipeline(pip_id, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_fail_pass(sg_pass pass_id, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_FAIL_PASS;
+ item->color = _SG_IMGUI_COLOR_RSRC;
+ item->args.fail_pass.pass = pass_id;
+ }
+ if (ctx->hooks.fail_pass) {
+ ctx->hooks.fail_pass(pass_id, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_push_debug_group(const char* name, void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_PUSH_DEBUG_GROUP;
+ item->color = _SG_IMGUI_COLOR_OTHER;
+ item->args.push_debug_group.name = _sg_imgui_make_str(name);
+ }
+ if (ctx->hooks.push_debug_group) {
+ ctx->hooks.push_debug_group(name, ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_pop_debug_group(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_POP_DEBUG_GROUP;
+ item->color = _SG_IMGUI_COLOR_OTHER;
+ }
+ if (ctx->hooks.pop_debug_group) {
+ ctx->hooks.pop_debug_group(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_buffer_pool_exhausted(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_BUFFER_POOL_EXHAUSTED;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_buffer_pool_exhausted) {
+ ctx->hooks.err_buffer_pool_exhausted(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_image_pool_exhausted(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_IMAGE_POOL_EXHAUSTED;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_image_pool_exhausted) {
+ ctx->hooks.err_image_pool_exhausted(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_shader_pool_exhausted(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_SHADER_POOL_EXHAUSTED;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_shader_pool_exhausted) {
+ ctx->hooks.err_shader_pool_exhausted(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_pipeline_pool_exhausted(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_PIPELINE_POOL_EXHAUSTED;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_pipeline_pool_exhausted) {
+ ctx->hooks.err_pipeline_pool_exhausted(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_pass_pool_exhausted(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_PASS_POOL_EXHAUSTED;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_pass_pool_exhausted) {
+ ctx->hooks.err_pass_pool_exhausted(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_context_mismatch(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_CONTEXT_MISMATCH;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_context_mismatch) {
+ ctx->hooks.err_context_mismatch(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_pass_invalid(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_PASS_INVALID;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_pass_invalid) {
+ ctx->hooks.err_pass_invalid(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_draw_invalid(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_DRAW_INVALID;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_draw_invalid) {
+ ctx->hooks.err_draw_invalid(ctx->hooks.user_data);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_err_bindings_invalid(void* user_data) {
+ sg_imgui_t* ctx = (sg_imgui_t*) user_data;
+ SOKOL_ASSERT(ctx);
+ sg_imgui_capture_item_t* item = _sg_imgui_capture_next_write_item(ctx);
+ if (item) {
+ item->cmd = SG_IMGUI_CMD_ERR_BINDINGS_INVALID;
+ item->color = _SG_IMGUI_COLOR_ERR;
+ }
+ if (ctx->hooks.err_bindings_invalid) {
+ ctx->hooks.err_bindings_invalid(ctx->hooks.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);
+ bool res;
+ if (label[0]) {
+ res = ImGui::Selectable(label, selected);
+ }
+ else {
+ char buf[32];
+ snprintf(buf, sizeof(buf), "0x%08X", res_id);
+ res = ImGui::Selectable(buf, selected);
+ }
+ ImGui::PopID();
+ return res;
+}
+
+_SOKOL_PRIVATE bool _sg_imgui_draw_resid_link(uint32_t res_id, const char* label) {
+ SOKOL_ASSERT(label);
+ char buf[32];
+ const char* str;
+ if (label[0]) {
+ str = label;
+ }
+ else {
+ snprintf(buf, sizeof(buf), "0x%08X", res_id);
+ str = buf;
+ }
+ ImGui::PushID((int)res_id);
+ bool res = ImGui::SmallButton(str);
+ ImGui::PopID();
+ return res;
+}
+
+_SOKOL_PRIVATE bool _sg_imgui_draw_buffer_link(sg_imgui_t* ctx, uint32_t buf_id) {
+ bool retval = false;
+ if (buf_id != SG_INVALID_ID) {
+ const sg_imgui_buffer_t* buf_ui = &ctx->buffers.slots[_sg_slot_index(buf_id)];
+ retval = _sg_imgui_draw_resid_link(buf_id, buf_ui->label.buf);
+ }
+ return retval;
+}
+
+_SOKOL_PRIVATE bool _sg_imgui_draw_image_link(sg_imgui_t* ctx, uint32_t img_id) {
+ bool retval = false;
+ if (img_id != SG_INVALID_ID) {
+ const sg_imgui_image_t* img_ui = &ctx->images.slots[_sg_slot_index(img_id)];
+ retval = _sg_imgui_draw_resid_link(img_id, img_ui->label.buf);
+ }
+ return retval;
+}
+
+_SOKOL_PRIVATE bool _sg_imgui_draw_shader_link(sg_imgui_t* ctx, uint32_t shd_id) {
+ bool retval = false;
+ if (shd_id != SG_INVALID_ID) {
+ const sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_slot_index(shd_id)];
+ retval = _sg_imgui_draw_resid_link(shd_id, shd_ui->label.buf);
+ }
+ return retval;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_show_buffer(sg_imgui_t* ctx, uint32_t buf_id) {
+ ctx->buffers.open = true;
+ ctx->buffers.sel_id = buf_id;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_show_image(sg_imgui_t* ctx, uint32_t img_id) {
+ ctx->images.open = true;
+ ctx->images.sel_id = img_id;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_show_shader(sg_imgui_t* ctx, uint32_t shd_id) {
+ ctx->shaders.open = true;
+ ctx->shaders.sel_id = shd_id;
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_buffer_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("buffer_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ for (int i = 1; i < _sg.pools.buffer_pool.size; i++) {
+ const _sg_buffer_t* buf = &_sg.pools.buffers[i];
+ if (buf->slot.state != SG_RESOURCESTATE_INITIAL) {
+ bool selected = ctx->buffers.sel_id == buf->slot.id;
+ if (_sg_imgui_draw_resid_list_item(buf->slot.id, ctx->buffers.slots[i].label.buf, selected)) {
+ ctx->buffers.sel_id = buf->slot.id;
+ }
+ }
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_image_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("image_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ for (int i = 1; i < _sg.pools.image_pool.size; i++) {
+ const _sg_image_t* img = &_sg.pools.images[i];
+ if (img->slot.state != SG_RESOURCESTATE_INITIAL) {
+ bool selected = ctx->images.sel_id == img->slot.id;
+ if (_sg_imgui_draw_resid_list_item(img->slot.id, ctx->images.slots[i].label.buf, selected)) {
+ ctx->images.sel_id = img->slot.id;
+ }
+ }
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_shader_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("shader_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ for (int i = 1; i < _sg.pools.shader_pool.size; i++) {
+ const _sg_shader_t* shd = &_sg.pools.shaders[i];
+ if (shd->slot.state != SG_RESOURCESTATE_INITIAL) {
+ bool selected = ctx->shaders.sel_id == shd->slot.id;
+ if (_sg_imgui_draw_resid_list_item(shd->slot.id, ctx->shaders.slots[i].label.buf, selected)) {
+ ctx->shaders.sel_id = shd->slot.id;
+ }
+ }
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_pipeline_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("pipeline_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ for (int i = 1; i < _sg.pools.pipeline_pool.size; i++) {
+ const _sg_pipeline_t* pip = &_sg.pools.pipelines[i];
+ if (pip->slot.state != SG_RESOURCESTATE_INITIAL) {
+ bool selected = ctx->pipelines.sel_id == pip->slot.id;
+ if (_sg_imgui_draw_resid_list_item(pip->slot.id, ctx->pipelines.slots[i].label.buf, selected)) {
+ ctx->pipelines.sel_id = pip->slot.id;
+ }
+ }
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_pass_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("pass_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ for (int i = 1; i < _sg.pools.pass_pool.size; i++) {
+ const _sg_pass_t* pass = &_sg.pools.passes[i];
+ if (pass->slot.state != SG_RESOURCESTATE_INITIAL) {
+ bool selected = ctx->passes.sel_id == pass->slot.id;
+ if (_sg_imgui_draw_resid_list_item(pass->slot.id, ctx->passes.slots[i].label.buf, selected)) {
+ ctx->passes.sel_id = pass->slot.id;
+ }
+ }
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_capture_list(sg_imgui_t* ctx) {
+ ImGui::BeginChild("capture_list", ImVec2(_SG_IMGUI_LIST_WIDTH,0), true);
+ 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);
+ 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)) {
+ group_stack |= 1;
+ }
+ }
+ else {
+ group_stack <<= 1;
+ }
+ }
+ else if (item->cmd == SG_IMGUI_CMD_POP_DEBUG_GROUP) {
+ if (group_stack & 1) {
+ ImGui::TreePop();
+ }
+ group_stack >>= 1;
+ }
+ else if (group_stack & 1) {
+ ImGui::PushID(i);
+ if (ImGui::Selectable(item_string.buf, ctx->capture.sel_item == i)) {
+ ctx->capture.sel_item = i;
+ }
+ if (ImGui::IsItemHovered()) {
+ ImGui::SetTooltip("%s", item_string.buf);
+ }
+ ImGui::PopID();
+ }
+ ImGui::PopStyleColor();
+ }
+ ImGui::EndChild();
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_buffer_panel(sg_imgui_t* ctx, uint32_t buf_id) {
+ if (buf_id != SG_INVALID_ID) {
+ ImGui::BeginChild("buffer", ImVec2(0,0), false);
+ const _sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id);
+ if (buf) {
+ const sg_imgui_buffer_t* buf_ui = &ctx->buffers.slots[_sg_slot_index(buf_id)];
+ ImGui::Text("Label: %s", buf_ui->label.buf[0] ? buf_ui->label.buf : "---");
+ _sg_imgui_draw_resource_slot(&buf->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);
+ if (buf_ui->desc.usage != SG_USAGE_IMMUTABLE) {
+ ImGui::Separator();
+ ImGui::Text("Num Slots: %d", buf->num_slots);
+ ImGui::Text("Active Slot: %d", buf->active_slot);
+ ImGui::Text("Update Frame Index: %d", buf->update_frame_index);
+ ImGui::Text("Append Frame Index: %d", buf->append_frame_index);
+ ImGui::Text("Append Pos: %d", buf->append_pos);
+ ImGui::Text("Append Overflow: %s", buf->append_overflow ? "YES":"NO");
+ }
+ }
+ else {
+ ImGui::Text("Buffer 0x%08X no longer alive", buf_id);
+ }
+ ImGui::EndChild();
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_embedded_image(sg_imgui_t* ctx, uint32_t img_id, float* scale) {
+ const _sg_image_t* img = _sg_lookup_image(&_sg.pools, img_id);
+ if (img) {
+ if ((SG_IMAGETYPE_2D == img->type) && !_sg_is_valid_rendertarget_depth_format(img->pixel_format)) {
+ ImGui::PushID((int)img_id);
+ ImGui::SliderFloat("Scale", scale, 0.125f, 8.0f, "%.3f", 2.0f);
+ float w = (float)img->width * (*scale);
+ float h = (float)img->height * (*scale);
+ ImGui::Image((ImTextureID)(intptr_t)img_id, ImVec2(w, h));
+ ImGui::PopID();
+ }
+ else {
+ ImGui::Text("Image not renderable.");
+ }
+ }
+ else {
+ ImGui::Text("Image 0x%08X no longer alive", img_id);
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_image_panel(sg_imgui_t* ctx, uint32_t img_id) {
+ if (img_id != SG_INVALID_ID) {
+ ImGui::BeginChild("image", ImVec2(0,0), false);
+ const _sg_image_t* img = _sg_lookup_image(&_sg.pools, img_id);
+ if (img) {
+ sg_imgui_image_t* img_ui = &ctx->images.slots[_sg_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 : "---");
+ _sg_imgui_draw_resource_slot(&img->slot);
+ ImGui::Separator();
+ _sg_imgui_draw_embedded_image(ctx, img_id, &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);
+ if (img->usage != SG_USAGE_IMMUTABLE) {
+ ImGui::Separator();
+ ImGui::Text("Num Slots: %d", img->num_slots);
+ ImGui::Text("Active Slot: %d", img->active_slot);
+ ImGui::Text("Update Frame Index: %d", img->upd_frame_index);
+ }
+ }
+ else {
+ ImGui::Text("Image 0x%08X no longer alive", img_id);
+ }
+ ImGui::EndChild();
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_shader_stage(sg_imgui_t* ctx, const sg_shader_stage_desc* stage) {
+ int num_valid_ubs = 0;
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_UBS; 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) {
+ num_valid_ubs++;
+ break;
+ }
+ }
+ }
+ int num_valid_images = 0;
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
+ if (_SG_IMAGETYPE_DEFAULT != stage->images[i].type) {
+ num_valid_images++;
+ }
+ else {
+ break;
+ }
+ }
+ if (num_valid_ubs > 0) {
+ if (ImGui::TreeNode("Uniform Blocks")) {
+ for (int i = 0; i < num_valid_ubs; i++) {
+ ImGui::Text("#%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 : "");
+ }
+ else {
+ ImGui::Text(" %s[%d] %s", _sg_imgui_uniformtype_string(u->type), u->array_count, u->name ? u->name : "");
+ }
+ }
+ }
+ }
+ ImGui::TreePop();
+ }
+ }
+ if (num_valid_images > 0) {
+ if (ImGui::TreeNode("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 : "");
+ }
+ else {
+ break;
+ }
+ }
+ ImGui::TreePop();
+ }
+ }
+ if (stage->entry) {
+ ImGui::Text("Entry: %s", stage->entry);
+ }
+ if (stage->source) {
+ if (ImGui::TreeNode("Source")) {
+ ImGui::Text("%s", stage->source);
+ ImGui::TreePop();
+ }
+ }
+ else if (stage->byte_code) {
+ if (ImGui::TreeNode("Byte Code")) {
+ ImGui::Text("Byte-code display currently not supported.");
+ }
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_shader_panel(sg_imgui_t* ctx, uint32_t shd_id) {
+ if (shd_id != SG_INVALID_ID) {
+ ImGui::BeginChild("shader", ImVec2(0,0), false, ImGuiWindowFlags_HorizontalScrollbar);
+ const _sg_shader_t* shd = _sg_lookup_shader(&_sg.pools, shd_id);
+ if (shd) {
+ const sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_slot_index(shd_id)];
+ ImGui::Text("Label: %s", shd_ui->label.buf[0] ? shd_ui->label.buf : "---");
+ _sg_imgui_draw_resource_slot(&shd->slot);
+ ImGui::Separator();
+ if (ImGui::TreeNode("Vertex Shader Stage")) {
+ _sg_imgui_draw_shader_stage(ctx, &shd_ui->desc.vs);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Fragment Shader Stage")) {
+ _sg_imgui_draw_shader_stage(ctx, &shd_ui->desc.fs);
+ ImGui::TreePop();
+ }
+ }
+ else {
+ ImGui::Text("Shader 0x%08X no longer alive", shd_id);
+ }
+ ImGui::EndChild();
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_vertex_layout(const sg_layout_desc* layout) {
+ if (ImGui::TreeNode("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);
+ }
+ }
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("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(" 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);
+ ImGui::Text(" Offset: %d", a_desc->offset);
+ ImGui::Text(" Buffer Index: %d", a_desc->buffer_index);
+ }
+ }
+ ImGui::TreePop();
+ }
+}
+
+_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));
+}
+
+_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")) {
+ _sg_imgui_draw_stencil_state(&dss->stencil_front);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Stencil Back")) {
+ _sg_imgui_draw_stencil_state(&dss->stencil_back);
+ ImGui::TreePop();
+ }
+}
+
+_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]);
+}
+
+_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);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_pipeline_panel(sg_imgui_t* ctx, uint32_t pip_id) {
+ if (pip_id != SG_INVALID_ID) {
+ ImGui::BeginChild("pipeline", ImVec2(0,0), false);
+ const _sg_pipeline_t* pip = _sg_lookup_pipeline(&_sg.pools, pip_id);
+ if (pip) {
+ const sg_imgui_pipeline_t* pip_ui = &ctx->pipelines.slots[_sg_slot_index(pip_id)];
+ ImGui::Text("Label: %s", pip_ui->label.buf[0] ? pip_ui->label.buf : "---");
+ _sg_imgui_draw_resource_slot(&pip->slot);
+ ImGui::Separator();
+ ImGui::Text("Shader: "); ImGui::SameLine();
+ if (_sg_imgui_draw_shader_link(ctx, pip->shader_id.id)) {
+ _sg_imgui_show_shader(ctx, pip->shader_id.id);
+ }
+ 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")) {
+ _sg_imgui_draw_vertex_layout(&pip_ui->desc.layout);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Depth Stencil State")) {
+ _sg_imgui_draw_depth_stencil_state(&pip_ui->desc.depth_stencil);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Blend State")) {
+ _sg_imgui_draw_blend_state(&pip_ui->desc.blend);
+ ImGui::TreePop();
+ }
+ if (ImGui::TreeNode("Rasterizer State")) {
+ _sg_imgui_draw_rasterizer_state(&pip_ui->desc.rasterizer);
+ ImGui::TreePop();
+ }
+ }
+ else {
+ ImGui::Text("Pipeline 0x%08X no longer alive.", pip_id);
+ }
+ ImGui::EndChild();
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_attachment(sg_imgui_t* ctx, const _sg_attachment_t* att, float* img_scale) {
+ SOKOL_ASSERT(att->image && (att->image->slot.id == att->image_id.id));
+ ImGui::Text(" Image: "); ImGui::SameLine();
+ if (_sg_imgui_draw_image_link(ctx, att->image_id.id)) {
+ _sg_imgui_show_image(ctx, att->image_id.id);
+ }
+ ImGui::Text(" Mip Level: %d", att->mip_level);
+ ImGui::Text(" Slice: %d", att->slice);
+ _sg_imgui_draw_embedded_image(ctx, att->image_id.id, img_scale);
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_pass_panel(sg_imgui_t* ctx, uint32_t pass_id) {
+ if (pass_id != SG_INVALID_ID) {
+ ImGui::BeginChild("pass", ImVec2(0,0), false);
+ const _sg_pass_t* pass = _sg_lookup_pass(&_sg.pools, pass_id);
+ if (pass) {
+ sg_imgui_pass_t* pass_ui = &ctx->passes.slots[_sg_slot_index(pass_id)];
+ ImGui::Text("Label: %s", pass_ui->label.buf[0] ? pass_ui->label.buf : "---");
+ _sg_imgui_draw_resource_slot(&pass->slot);
+ for (int i = 0; i < pass->num_color_atts; i++) {
+ ImGui::Separator();
+ ImGui::Text("Color Attachment #%d:", i);
+ _sg_imgui_draw_attachment(ctx, &pass->color_atts[i], &pass_ui->color_image_scale[i]);
+ }
+ if (pass->ds_att.image_id.id != SG_INVALID_ID) {
+ ImGui::Separator();
+ ImGui::Text("Depth-Stencil Attachemnt:");
+ _sg_imgui_draw_attachment(ctx, &pass->ds_att, &pass_ui->ds_image_scale);
+ }
+ }
+ else {
+ ImGui::Text("Pass 0x%08X no longer alive.", pass_id);
+ }
+ ImGui::EndChild();
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_bindings_panel(sg_imgui_t* ctx, const sg_bindings* bnd) {
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++) {
+ uint32_t buf_id = bnd->vertex_buffers[i].id;
+ if (buf_id != SG_INVALID_ID) {
+ ImGui::Separator();
+ ImGui::Text("Vertex Buffer Slot #%d:", i);
+ ImGui::Text(" Buffer: "); ImGui::SameLine();
+ if (_sg_imgui_draw_buffer_link(ctx, buf_id)) {
+ _sg_imgui_show_buffer(ctx, buf_id);
+ }
+ ImGui::Text(" Offset: %d", bnd->vertex_buffer_offsets[i]);
+ }
+ else {
+ break;
+ }
+ }
+ if (bnd->index_buffer.id != SG_INVALID_ID) {
+ uint32_t buf_id = bnd->index_buffer.id;
+ if (buf_id != SG_INVALID_ID) {
+ ImGui::Separator();
+ ImGui::Text("Index Buffer Slot:");
+ ImGui::Text(" Buffer: "); ImGui::SameLine();
+ if (_sg_imgui_draw_buffer_link(ctx, buf_id)) {
+ _sg_imgui_show_buffer(ctx, buf_id);
+ }
+ ImGui::Text(" Offset: %d", bnd->index_buffer_offset);
+ }
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
+ uint32_t img_id = bnd->vs_images[i].id;
+ if (img_id != SG_INVALID_ID) {
+ ImGui::Separator();
+ ImGui::Text("Vertex Stage Image Slot #%d:", i);
+ ImGui::Text(" Image: "); ImGui::SameLine();
+ if (_sg_imgui_draw_image_link(ctx, img_id)) {
+ _sg_imgui_show_image(ctx, img_id);
+ }
+ }
+ else {
+ break;
+ }
+ }
+ for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
+ uint32_t img_id = bnd->fs_images[i].id;
+ if (img_id != SG_INVALID_ID) {
+ ImGui::Separator();
+ ImGui::Text("Fragment Stage Image Slot #%d:", i);
+ ImGui::Text(" Image: "); ImGui::SameLine();
+ if (_sg_imgui_draw_image_link(ctx, img_id)) {
+ _sg_imgui_show_image(ctx, img_id);
+ }
+ }
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_uniforms_panel(sg_imgui_t* ctx, const sg_imgui_args_apply_uniforms_t* args) {
+ SOKOL_ASSERT(args->ub_index < SG_MAX_SHADERSTAGE_BUFFERS);
+
+ /* check if all the required information for drawing the structured uniform block content
+ is available, otherwise just render a generic hexdump
+ */
+ bool draw_dump = false;
+ _sg_pipeline_t* pip = _sg_lookup_pipeline(&_sg.pools, args->pipeline.id);
+ if (!pip) {
+ ImGui::Text("Pipeline object no longer alive!");
+ draw_dump = true;
+ }
+ _sg_shader_t* shd = _sg_lookup_shader(&_sg.pools, pip->shader_id.id);
+ if (!shd) {
+ ImGui::Text("Shader object no longer alive!");
+ draw_dump = true;
+ }
+ const sg_imgui_shader_t* shd_ui = &ctx->shaders.slots[_sg_slot_index(pip->shader_id.id)];
+ SOKOL_ASSERT(shd_ui->res_id.id == pip->shader_id.id);
+ const sg_shader_uniform_block_desc* ub_desc = (args->stage == SG_SHADERSTAGE_VS) ?
+ ub_desc = &shd_ui->desc.vs.uniform_blocks[args->ub_index] :
+ ub_desc = &shd_ui->desc.fs.uniform_blocks[args->ub_index];
+ SOKOL_ASSERT(args->num_bytes <= ub_desc->size);
+ if (ub_desc->uniforms[0].type == SG_UNIFORMTYPE_INVALID) {
+ draw_dump = true;
+ }
+
+ sg_imgui_capture_bucket_t* bucket = _sg_imgui_capture_get_read_bucket(ctx);
+ SOKOL_ASSERT((args->ubuf_pos + args->num_bytes) <= bucket->ubuf_size);
+ const float* uptrf = (const float*) (bucket->ubuf + args->ubuf_pos);
+ if (!draw_dump) {
+ for (int i = 0; i < SG_MAX_UB_MEMBERS; i++) {
+ const sg_shader_uniform_desc* ud = &ub_desc->uniforms[i];
+ if (ud->type == SG_UNIFORMTYPE_INVALID) {
+ break;
+ }
+ 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);
+ }
+ else {
+ ImGui::Text("%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);
+ break;
+ case SG_UNIFORMTYPE_FLOAT2:
+ ImGui::Text(" %.3f, %.3f", uptrf[0], uptrf[1]);
+ break;
+ case SG_UNIFORMTYPE_FLOAT3:
+ ImGui::Text(" %.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]);
+ 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",
+ 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("???");
+ break;
+ }
+ uptrf += _sg_uniform_size(ud->type, 1) / sizeof(float);
+ }
+ }
+ }
+ 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]);
+ if (((i + 1) % 4) != 0) {
+ ImGui::SameLine();
+ }
+ }
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_passaction_panel(sg_imgui_t* ctx, uint32_t pass_id, const sg_pass_action* action) {
+ int num_color_atts = 1;
+ if (SG_INVALID_ID != pass_id) {
+ const _sg_pass_t* pass = _sg_lookup_pass(&_sg.pools, pass_id);
+ if (pass) {
+ num_color_atts = pass->num_color_atts;
+ }
+ }
+
+ ImGui::Text("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);
+ switch (c_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, %.3f, %.3f, %.3f",
+ c_att->val[0],
+ c_att->val[1],
+ c_att->val[2],
+ c_att->val[3]);
+ break;
+ }
+ }
+ const sg_depth_attachment_action* d_att = &action->depth;
+ ImGui::Text(" 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;
+ }
+ const sg_stencil_attachment_action* s_att = &action->stencil;
+ ImGui::Text(" 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;
+ }
+}
+
+_SOKOL_PRIVATE void _sg_imgui_draw_capture_panel(sg_imgui_t* ctx) {
+ uint32_t sel_item_index = ctx->capture.sel_item;
+ if (sel_item_index >= _sg_imgui_capture_num_read_items(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();
+ switch (item->cmd) {
+ case SG_IMGUI_CMD_QUERY_FEATURE:
+ break;
+ case SG_IMGUI_CMD_RESET_STATE_CACHE:
+ break;
+ case SG_IMGUI_CMD_MAKE_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.make_buffer.result.id);
+ break;
+ case SG_IMGUI_CMD_MAKE_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.make_image.result.id);
+ break;
+ case SG_IMGUI_CMD_MAKE_SHADER:
+ _sg_imgui_draw_shader_panel(ctx, item->args.make_shader.result.id);
+ break;
+ case SG_IMGUI_CMD_MAKE_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.make_pipeline.result.id);
+ break;
+ case SG_IMGUI_CMD_MAKE_PASS:
+ _sg_imgui_draw_pass_panel(ctx, item->args.make_pass.result.id);
+ break;
+ case SG_IMGUI_CMD_DESTROY_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.destroy_buffer.buffer.id);
+ break;
+ case SG_IMGUI_CMD_DESTROY_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.destroy_image.image.id);
+ break;
+ case SG_IMGUI_CMD_DESTROY_SHADER:
+ _sg_imgui_draw_shader_panel(ctx, item->args.destroy_shader.shader.id);
+ break;
+ case SG_IMGUI_CMD_DESTROY_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.destroy_pipeline.pipeline.id);
+ break;
+ case SG_IMGUI_CMD_DESTROY_PASS:
+ _sg_imgui_draw_pass_panel(ctx, item->args.destroy_pass.pass.id);
+ break;
+ case SG_IMGUI_CMD_UPDATE_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.update_buffer.buffer.id);
+ break;
+ case SG_IMGUI_CMD_UPDATE_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.update_image.image.id);
+ break;
+ case SG_IMGUI_CMD_APPEND_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.update_buffer.buffer.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_BUFFER_OVERFLOW:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.query_buffer_overflow.buffer.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_BUFFER_STATE:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.query_buffer_state.buffer.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_IMAGE_STATE:
+ _sg_imgui_draw_image_panel(ctx, item->args.query_image_state.image.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_SHADER_STATE:
+ _sg_imgui_draw_shader_panel(ctx, item->args.query_shader_state.shader.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_PIPELINE_STATE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.query_pipeline_state.pipeline.id);
+ break;
+ case SG_IMGUI_CMD_QUERY_PASS_STATE:
+ _sg_imgui_draw_pass_panel(ctx, item->args.query_pass_state.pass.id);
+ break;
+ case SG_IMGUI_CMD_BEGIN_DEFAULT_PASS:
+ _sg_imgui_draw_passaction_panel(ctx, SG_INVALID_ID, &item->args.begin_default_pass.action);
+ break;
+ case SG_IMGUI_CMD_BEGIN_PASS:
+ _sg_imgui_draw_passaction_panel(ctx, item->args.begin_pass.pass.id, &item->args.begin_pass.action);
+ ImGui::Separator();
+ _sg_imgui_draw_pass_panel(ctx, item->args.begin_pass.pass.id);
+ break;
+ case SG_IMGUI_CMD_APPLY_VIEWPORT:
+ case SG_IMGUI_CMD_APPLY_SCISSOR_RECT:
+ break;
+ case SG_IMGUI_CMD_APPLY_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.apply_pipeline.pipeline.id);
+ break;
+ case SG_IMGUI_CMD_APPLY_BINDINGS:
+ _sg_imgui_draw_bindings_panel(ctx, &item->args.apply_bindings.bindings);
+ break;
+ case SG_IMGUI_CMD_APPLY_UNIFORMS:
+ _sg_imgui_draw_uniforms_panel(ctx, &item->args.apply_uniforms);
+ break;
+ case SG_IMGUI_CMD_DRAW:
+ case SG_IMGUI_CMD_END_PASS:
+ case SG_IMGUI_CMD_COMMIT:
+ break;
+ case SG_IMGUI_CMD_ALLOC_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.alloc_buffer.result.id);
+ break;
+ case SG_IMGUI_CMD_ALLOC_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.alloc_image.result.id);
+ break;
+ case SG_IMGUI_CMD_ALLOC_SHADER:
+ _sg_imgui_draw_shader_panel(ctx, item->args.alloc_shader.result.id);
+ break;
+ case SG_IMGUI_CMD_ALLOC_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.alloc_pipeline.result.id);
+ break;
+ case SG_IMGUI_CMD_ALLOC_PASS:
+ _sg_imgui_draw_pass_panel(ctx, item->args.alloc_pass.result.id);
+ break;
+ case SG_IMGUI_CMD_INIT_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.init_buffer.buffer.id);
+ break;
+ case SG_IMGUI_CMD_INIT_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.init_image.image.id);
+ break;
+ case SG_IMGUI_CMD_INIT_SHADER:
+ _sg_imgui_draw_shader_panel(ctx, item->args.init_shader.shader.id);
+ break;
+ case SG_IMGUI_CMD_INIT_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.init_pipeline.pipeline.id);
+ break;
+ case SG_IMGUI_CMD_INIT_PASS:
+ _sg_imgui_draw_pass_panel(ctx, item->args.init_pass.pass.id);
+ break;
+ case SG_IMGUI_CMD_FAIL_BUFFER:
+ _sg_imgui_draw_buffer_panel(ctx, item->args.fail_buffer.buffer.id);
+ break;
+ case SG_IMGUI_CMD_FAIL_IMAGE:
+ _sg_imgui_draw_image_panel(ctx, item->args.fail_image.image.id);
+ break;
+ case SG_IMGUI_CMD_FAIL_SHADER:
+ _sg_imgui_draw_shader_panel(ctx, item->args.fail_shader.shader.id);
+ break;
+ case SG_IMGUI_CMD_FAIL_PIPELINE:
+ _sg_imgui_draw_pipeline_panel(ctx, item->args.fail_pipeline.pipeline.id);
+ break;
+ case SG_IMGUI_CMD_FAIL_PASS:
+ _sg_imgui_draw_pass_panel(ctx, item->args.fail_pass.pass.id);
+ break;
+ default:
+ break;
+ }
+ ImGui::EndChild();
+}
+
+/*--- PUBLIC FUNCTIONS -------------------------------------------------------*/
+SOKOL_API_IMPL void sg_imgui_init(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx);
+ memset(ctx, 0, sizeof(sg_imgui_t));
+ ctx->init_tag = 0xABCDABCD;
+ _sg_imgui_capture_init(ctx);
+
+ /* hook into sokol_gfx functions */
+ sg_trace_hooks hooks;
+ memset(&hooks, 0, sizeof(hooks));
+ hooks.user_data = (void*) ctx;
+ hooks.query_feature = _sg_imgui_query_feature;
+ hooks.reset_state_cache = _sg_imgui_reset_state_cache;
+ hooks.make_buffer = _sg_imgui_make_buffer;
+ hooks.make_image = _sg_imgui_make_image;
+ hooks.make_shader = _sg_imgui_make_shader;
+ hooks.make_pipeline = _sg_imgui_make_pipeline;
+ hooks.make_pass = _sg_imgui_make_pass;
+ hooks.destroy_buffer = _sg_imgui_destroy_buffer;
+ hooks.destroy_image = _sg_imgui_destroy_image;
+ hooks.destroy_shader = _sg_imgui_destroy_shader;
+ hooks.destroy_pipeline = _sg_imgui_destroy_pipeline;
+ hooks.destroy_pass = _sg_imgui_destroy_pass;
+ hooks.update_buffer = _sg_imgui_update_buffer;
+ hooks.update_image = _sg_imgui_update_image;
+ hooks.append_buffer = _sg_imgui_append_buffer;
+ hooks.query_buffer_overflow = _sg_imgui_query_buffer_overflow;
+ hooks.query_buffer_state = _sg_imgui_query_buffer_state;
+ hooks.query_image_state = _sg_imgui_query_image_state;
+ hooks.query_shader_state = _sg_imgui_query_shader_state;
+ hooks.query_pipeline_state = _sg_imgui_query_pipeline_state;
+ hooks.query_pass_state = _sg_imgui_query_pass_state;
+ hooks.begin_default_pass = _sg_imgui_begin_default_pass;
+ hooks.begin_pass = _sg_imgui_begin_pass;
+ hooks.apply_viewport = _sg_imgui_apply_viewport;
+ hooks.apply_scissor_rect = _sg_imgui_apply_scissor_rect;
+ hooks.apply_pipeline = _sg_imgui_apply_pipeline;
+ hooks.apply_bindings = _sg_imgui_apply_bindings;
+ hooks.apply_uniforms = _sg_imgui_apply_uniforms;
+ hooks.draw = _sg_imgui_draw;
+ hooks.end_pass = _sg_imgui_end_pass;
+ hooks.commit = _sg_imgui_commit;
+ hooks.alloc_buffer = _sg_imgui_alloc_buffer;
+ hooks.alloc_image = _sg_imgui_alloc_image;
+ hooks.alloc_shader = _sg_imgui_alloc_shader;
+ hooks.alloc_pipeline = _sg_imgui_alloc_pipeline;
+ hooks.alloc_pass = _sg_imgui_alloc_pass;
+ hooks.init_buffer = _sg_imgui_init_buffer;
+ hooks.init_image = _sg_imgui_init_image;
+ hooks.init_shader = _sg_imgui_init_shader;
+ hooks.init_pipeline = _sg_imgui_init_pipeline;
+ hooks.init_pass = _sg_imgui_init_pass;
+ hooks.fail_buffer = _sg_imgui_fail_buffer;
+ hooks.fail_image = _sg_imgui_fail_image;
+ hooks.fail_shader = _sg_imgui_fail_shader;
+ hooks.fail_pipeline = _sg_imgui_fail_pipeline;
+ hooks.fail_pass = _sg_imgui_fail_pass;
+ hooks.push_debug_group = _sg_imgui_push_debug_group;
+ hooks.pop_debug_group = _sg_imgui_pop_debug_group;
+ hooks.err_buffer_pool_exhausted = _sg_imgui_err_buffer_pool_exhausted;
+ hooks.err_image_pool_exhausted = _sg_imgui_err_image_pool_exhausted;
+ hooks.err_shader_pool_exhausted = _sg_imgui_err_shader_pool_exhausted;
+ hooks.err_pipeline_pool_exhausted = _sg_imgui_err_pipeline_pool_exhausted;
+ hooks.err_pass_pool_exhausted = _sg_imgui_err_pass_pool_exhausted;
+ hooks.err_context_mismatch = _sg_imgui_err_context_mismatch;
+ hooks.err_pass_invalid = _sg_imgui_err_pass_invalid;
+ hooks.err_draw_invalid = _sg_imgui_err_draw_invalid;
+ hooks.err_bindings_invalid = _sg_imgui_err_bindings_invalid;
+ ctx->hooks = sg_install_trace_hooks(&hooks);
+
+ /* allocate resource debug-info slots */
+ ctx->buffers.num_slots = _sg.pools.buffer_pool.size;
+ ctx->images.num_slots = _sg.pools.image_pool.size;
+ ctx->shaders.num_slots = _sg.pools.shader_pool.size;
+ ctx->pipelines.num_slots = _sg.pools.pipeline_pool.size;
+ ctx->passes.num_slots = _sg.pools.pass_pool.size;
+
+ const int buffer_pool_size = ctx->buffers.num_slots * sizeof(sg_imgui_buffer_t);
+ ctx->buffers.slots = (sg_imgui_buffer_t*) _sg_imgui_alloc(buffer_pool_size);
+ SOKOL_ASSERT(ctx->buffers.slots);
+ memset(ctx->buffers.slots, 0, buffer_pool_size);
+
+ const int image_pool_size = ctx->images.num_slots * sizeof(sg_imgui_image_t);
+ ctx->images.slots = (sg_imgui_image_t*) _sg_imgui_alloc(image_pool_size);
+ SOKOL_ASSERT(ctx->images.slots);
+ memset(ctx->images.slots, 0, image_pool_size);
+
+ const int shader_pool_size = ctx->shaders.num_slots * sizeof(sg_imgui_shader_t);
+ ctx->shaders.slots = (sg_imgui_shader_t*) _sg_imgui_alloc(shader_pool_size);
+ SOKOL_ASSERT(ctx->shaders.slots);
+ memset(ctx->shaders.slots, 0, shader_pool_size);
+
+ const int pipeline_pool_size = ctx->pipelines.num_slots * sizeof(sg_imgui_pipeline_t);
+ ctx->pipelines.slots = (sg_imgui_pipeline_t*) _sg_imgui_alloc(pipeline_pool_size);
+ SOKOL_ASSERT(ctx->pipelines.slots);
+ memset(ctx->pipelines.slots, 0, pipeline_pool_size);
+
+ const int pass_pool_size = ctx->passes.num_slots * sizeof(sg_imgui_pass_t);
+ ctx->passes.slots = (sg_imgui_pass_t*) _sg_imgui_alloc(pass_pool_size);
+ SOKOL_ASSERT(ctx->passes.slots);
+ memset(ctx->passes.slots, 0, pass_pool_size);
+}
+
+SOKOL_API_IMPL void sg_imgui_discard(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ ctx->init_tag = 0;
+ _sg_imgui_capture_discard(ctx);
+ if (ctx->buffers.slots) {
+ for (int i = 0; i < ctx->buffers.num_slots; i++) {
+ if (ctx->buffers.slots[i].res_id.id != SG_INVALID_ID) {
+ _sg_imgui_buffer_destroyed(ctx, i);
+ }
+ }
+ _sg_imgui_free((void*)ctx->buffers.slots);
+ ctx->buffers.slots = 0;
+ }
+ if (ctx->images.slots) {
+ for (int i = 0; i < ctx->images.num_slots; i++) {
+ if (ctx->images.slots[i].res_id.id != SG_INVALID_ID) {
+ _sg_imgui_image_destroyed(ctx, i);
+ }
+ }
+ _sg_imgui_free((void*)ctx->images.slots);
+ ctx->images.slots = 0;
+ }
+ if (ctx->shaders.slots) {
+ for (int i = 0; i < ctx->shaders.num_slots; i++) {
+ if (ctx->shaders.slots[i].res_id.id != SG_INVALID_ID) {
+ _sg_imgui_shader_destroyed(ctx, i);
+ }
+ }
+ _sg_imgui_free((void*)ctx->shaders.slots);
+ ctx->shaders.slots = 0;
+ }
+ if (ctx->pipelines.slots) {
+ for (int i = 0; i < ctx->pipelines.num_slots; i++) {
+ if (ctx->pipelines.slots[i].res_id.id != SG_INVALID_ID) {
+ _sg_imgui_pipeline_destroyed(ctx, i);
+ }
+ }
+ _sg_imgui_free((void*)ctx->pipelines.slots);
+ ctx->pipelines.slots = 0;
+ }
+ if (ctx->passes.slots) {
+ for (int i = 0; i < ctx->passes.num_slots; i++) {
+ if (ctx->passes.slots[i].res_id.id != SG_INVALID_ID) {
+ _sg_imgui_pass_destroyed(ctx, i);
+ }
+ }
+ _sg_imgui_free((void*)ctx->passes.slots);
+ ctx->passes.slots = 0;
+ }
+}
+
+SOKOL_API_IMPL void sg_imgui_draw(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ sg_imgui_draw_buffers_window(ctx);
+ sg_imgui_draw_images_window(ctx);
+ sg_imgui_draw_shaders_window(ctx);
+ sg_imgui_draw_pipelines_window(ctx);
+ sg_imgui_draw_passes_window(ctx);
+ sg_imgui_draw_capture_window(ctx);
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_buffers_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->buffers.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(440, 280), ImGuiSetCond_Once);
+ if (ImGui::Begin("Buffers", &ctx->buffers.open)) {
+ sg_imgui_draw_buffers_content(ctx);
+ }
+ ImGui::End();
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_images_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->images.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiSetCond_Once);
+ if (ImGui::Begin("Images", &ctx->images.open)) {
+ sg_imgui_draw_images_content(ctx);
+ }
+ ImGui::End();
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_shaders_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->shaders.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiSetCond_Once);
+ if (ImGui::Begin("Shaders", &ctx->shaders.open)) {
+ sg_imgui_draw_shaders_content(ctx);
+ }
+ ImGui::End();
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_pipelines_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->pipelines.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(540, 400), ImGuiSetCond_Once);
+ if (ImGui::Begin("Pipelines", &ctx->pipelines.open)) {
+ sg_imgui_draw_pipelines_content(ctx);
+ }
+ ImGui::End();
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_passes_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->passes.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(440, 400), ImGuiSetCond_Once);
+ if (ImGui::Begin("Passes", &ctx->passes.open)) {
+ sg_imgui_draw_passes_content(ctx);
+ }
+ ImGui::End();
+}
+
+SOKOL_API_IMPL void sg_imgui_draw_capture_window(sg_imgui_t* ctx) {
+ SOKOL_ASSERT(ctx && (ctx->init_tag == 0xABCDABCD));
+ if (!ctx->capture.open) {
+ return;
+ }
+ ImGui::SetNextWindowSize(ImVec2(640, 400), ImGuiSetCond_Once);
+ if (ImGui::Begin("Frame Capture", &ctx->capture.open)) {
+ sg_imgui_draw_capture_content(ctx);
+ }
+ ImGui::End();
+}
+
+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();
+ _sg_imgui_draw_buffer_panel(ctx, ctx->buffers.sel_id);
+}
+
+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();
+ _sg_imgui_draw_image_panel(ctx, ctx->images.sel_id);
+}
+
+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();
+ _sg_imgui_draw_shader_panel(ctx, ctx->shaders.sel_id);
+}
+
+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();
+ _sg_imgui_draw_pipeline_panel(ctx, ctx->pipelines.sel_id);
+}
+
+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();
+ _sg_imgui_draw_pass_panel(ctx, ctx->passes.sel_id);
+}
+
+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();
+ _sg_imgui_draw_capture_panel(ctx);
+}
+
+#endif /* SOKOL_IMPL */
diff --git a/sokol_gfx.h b/sokol_gfx.h
index bb2c31b1..d6029c2a 100644
--- a/sokol_gfx.h
+++ b/sokol_gfx.h
@@ -43,6 +43,7 @@
SOKOL_UNREACHABLE() - a guard macro for unreachable code (default: assert(false))
SOKOL_API_DECL - public function declaration prefix (default: extern)
SOKOL_API_IMPL - public function implementation prefix (default: -)
+ SOKOL_TRACE_HOOKS - enable trace hook callbacks (search below for TRACE HOOKS)
If you want to compile without deprecated structs and functions,
define:
@@ -349,6 +350,35 @@
https://github.com/floooh/sokol-samples/blob/master/glfw/multiwindow-glfw.c
+ TRACE HOOKS:
+ ============
+ sokol_gfx.h optionally allows to install "trace hook" callbacks for
+ each public API functions. When a public API function is called, and
+ a trace hook callback has been installed for this function, the
+ callback will be invoked with the parameters and result of the function.
+ This is useful for things like debugging- and profiling-tools, or
+ keeping track of resource creation and destruction.
+
+ To use the trace hook feature:
+
+ --- Define SOKOL_TRACE_HOOKS before including the implementation.
+
+ --- Setup an sg_trace_hooks structure with your callback function
+ pointers (keep all function pointers you're not interested
+ in zero-initialized), optionally set the user_data member
+ in the sg_trace_hooks struct.
+
+ --- Install the trace hooks by calling sg_install_trace_hooks(),
+ the return value of this function is another sg_trace_hooks
+ struct which contains the previously set of trace hooks.
+ You should keep this struct around, and call those previous
+ functions pointers from your own trace callbacks for proper
+ chaining.
+
+ As an example of how trace hooks are used, have a look at the
+ imgui/sokol_gfx_imgui.h header which implements a realtime
+ debugging UI for sokol_gfx.h on top of Dear ImGui.
+
TODO:
====
- talk about asynchronous resource creation
@@ -1065,95 +1095,6 @@ typedef struct sg_bindings {
} sg_bindings;
/*
- sg_desc
-
- The sg_desc struct contains configuration values for sokol_gfx,
- it is used as parameter to the sg_setup() call.
-
- The default configuration is:
-
- .buffer_pool_size: 128
- .image_pool_size: 128
- .shader_pool_size: 32
- .pipeline_pool_size: 64
- .pass_pool_size: 16
- .context_pool_size: 16
-
- GL specific:
- .gl_force_gles2
- if this is true the GL backend will act in "GLES2 fallback mode" even
- when compiled with SOKOL_GLES3, this is useful to fall back
- to traditional WebGL if a browser doesn't support a WebGL2 context
-
- Metal specific:
- (NOTE: All Objective-C object references are transferred through
- a bridged (const void*) to sokol_gfx, which will use a unretained
- bridged cast (__bridged id<xxx>) to retrieve the Objective-C
- references back. Since the bridge cast is unretained, the caller
- must hold a strong reference to the Objective-C object for the
- duration of the sokol_gfx call!
-
- .mtl_device
- a pointer to the MTLDevice object
- .mtl_renderpass_descriptor_cb
- a C callback function to obtain the MTLRenderPassDescriptor for the
- current frame when rendering to the default framebuffer, will be called
- in sg_begin_default_pass()
- .mtl_drawable_cb
- a C callback function to obtain a MTLDrawable for the current
- frame when rendering to the default framebuffer, will be called in
- sg_end_pass() of the default pass
- .mtl_global_uniform_buffer_size
- the size of the global uniform buffer in bytes, this must be big
- enough to hold all uniform block updates for a single frame,
- the default value is 4 MByte (4 * 1024 * 1024)
- .mtl_sampler_cache_size
- the number of slots in the sampler cache, the Metal backend
- will share texture samplers with the same state in this
- cache, the default value is 64
-
- D3D11 specific:
- .d3d11_device
- a pointer to the ID3D11Device object, this must have been created
- before sg_setup() is called
- .d3d11_device_context
- a pointer to the ID3D11DeviceContext object
- .d3d11_render_target_view_cb
- a C callback function to obtain a pointer to the current
- ID3D11RenderTargetView object of the default framebuffer,
- this function will be called in sg_begin_pass() when rendering
- to the default framebuffer
- .d3d11_depth_stencil_view_cb
- a C callback function to obtain a pointer to the current
- ID3D11DepthStencilView object of the default framebuffer,
- this function will be called in sg_begin_pass() when rendering
- to the default framebuffer
-*/
-typedef struct sg_desc {
- uint32_t _start_canary;
- int buffer_pool_size;
- int image_pool_size;
- int shader_pool_size;
- int pipeline_pool_size;
- int pass_pool_size;
- int context_pool_size;
- /* GL specific */
- bool gl_force_gles2;
- /* Metal-specific */
- const void* mtl_device;
- const void* (*mtl_renderpass_descriptor_cb)(void);
- const void* (*mtl_drawable_cb)(void);
- int mtl_global_uniform_buffer_size;
- int mtl_sampler_cache_size;
- /* D3D11-specific */
- const void* d3d11_device;
- const void* d3d11_device_context;
- const void* (*d3d11_render_target_view_cb)(void);
- const void* (*d3d11_depth_stencil_view_cb)(void);
- uint32_t _end_canary;
-} sg_desc;
-
-/*
sg_buffer_desc
Creation parameters for sg_buffer objects, used in the
@@ -1165,10 +1106,11 @@ typedef struct sg_desc {
.type: SG_BUFFERTYPE_VERTEXBUFFER
.usage: SG_USAGE_IMMUTABLE
.content 0
+ .label 0 (optional string label for trace hooks)
- Buffers with the SG_USAGE_IMMUTABLE usage *must* fill the buffer
- with initial data (.content must point to a data chunk with
- exactly .size bytes).
+ The dbg_label will be ignored by sokol_gfx.h, it is only useful
+ when hooking into sg_make_buffer() or sg_init_buffer() via
+ the sg_install_trace_hook
ADVANCED TOPIC: Injecting native 3D-API buffers:
@@ -1199,6 +1141,7 @@ typedef struct sg_buffer_desc {
sg_buffer_type type;
sg_usage usage;
const void* content;
+ const char* label;
/* GL specific */
uint32_t gl_buffers[SG_NUM_INFLIGHT_FRAMES];
/* Metal specific */
@@ -1263,6 +1206,7 @@ typedef struct sg_image_content {
.min_lod 0.0f
.max_lod FLT_MAX
.content an sg_image_content struct to define the initial content
+ .label 0 (optional string label for trace hooks)
SG_IMAGETYPE_ARRAY and SG_IMAGETYPE_3D are not supported on
WebGL/GLES2, use sg_query_feature(SG_FEATURE_IMAGETYPE_ARRAY) and
@@ -1308,6 +1252,7 @@ typedef struct sg_image_desc {
float min_lod;
float max_lod;
sg_image_content content;
+ const char* label;
/* GL specific */
uint32_t gl_textures[SG_NUM_INFLIGHT_FRAMES];
/* Metal specific */
@@ -1354,6 +1299,7 @@ typedef struct sg_shader_desc {
uint32_t _start_canary;
sg_shader_stage_desc vs;
sg_shader_stage_desc fs;
+ const char* label;
uint32_t _end_canary;
} sg_shader_desc;
@@ -1429,6 +1375,7 @@ typedef struct sg_shader_desc {
.depth_bias: 0.0f
.depth_bias_slope_scale: 0.0f
.depth_bias_clamp: 0.0f
+ .label 0 (optional string label for trace hooks)
*/
typedef struct sg_buffer_layout_desc {
int stride;
@@ -1502,6 +1449,7 @@ typedef struct sg_pipeline_desc {
sg_depth_stencil_state depth_stencil;
sg_blend_state blend;
sg_rasterizer_state rasterizer;
+ const char* label;
uint32_t _end_canary;
} sg_pipeline_desc;
@@ -1542,15 +1490,181 @@ typedef struct sg_pass_desc {
uint32_t _start_canary;
sg_attachment_desc color_attachments[SG_MAX_COLOR_ATTACHMENTS];
sg_attachment_desc depth_stencil_attachment;
+ const char* label;
uint32_t _end_canary;
} sg_pass_desc;
+/*
+ sg_trace_hooks
+
+ Installable callback function to keep track of the sokol_gfx calls,
+ this is useful for debugging, or keeping track of resource creation
+ and destruction.
+
+ Trace hooks are installed with sg_install_trace_hooks(), this returns
+ another sg_trace_hooks functions with the previous set of
+ trace hook function pointers. These should be invoked by the
+ new trace hooks to form a proper call chain.
+*/
+typedef struct sg_trace_hooks {
+ void* user_data;
+ void (*query_feature)(sg_feature feature, bool result, void* user_data);
+ void (*reset_state_cache)(void* user_data);
+ void (*make_buffer)(const sg_buffer_desc* desc, sg_buffer result, void* user_data);
+ void (*make_image)(const sg_image_desc* desc, sg_image result, void* user_data);
+ void (*make_shader)(const sg_shader_desc* desc, sg_shader result, void* user_data);
+ void (*make_pipeline)(const sg_pipeline_desc* desc, sg_pipeline result, void* user_data);
+ void (*make_pass)(const sg_pass_desc* desc, sg_pass result, void* user_data);
+ void (*destroy_buffer)(sg_buffer buf, void* user_data);
+ void (*destroy_image)(sg_image img, void* user_data);
+ void (*destroy_shader)(sg_shader shd, void* user_data);
+ void (*destroy_pipeline)(sg_pipeline pip, void* user_data);
+ void (*destroy_pass)(sg_pass pass, void* user_data);
+ void (*update_buffer)(sg_buffer buf, const void* data_ptr, int data_size, void* user_data);
+ void (*update_image)(sg_image img, const sg_image_content* data, void* user_data);
+ void (*append_buffer)(sg_buffer buf, const void* data_ptr, int data_size, int result, void* user_data);
+ void (*query_buffer_overflow)(sg_buffer buf, bool result, void* user_data);
+ void (*query_buffer_state)(sg_buffer buf, sg_resource_state result, void* user_data);
+ void (*query_image_state)(sg_image img, sg_resource_state result, void* user_data);
+ void (*query_shader_state)(sg_shader shd, sg_resource_state result, void* user_data);
+ void (*query_pipeline_state)(sg_pipeline pip, sg_resource_state result, void* user_data);
+ void (*query_pass_state)(sg_pass pass, sg_resource_state result, void* user_data);
+ void (*begin_default_pass)(const sg_pass_action* pass_action, int width, int height, void* user_data);
+ void (*begin_pass)(sg_pass pass, const sg_pass_action* pass_action, void* user_data);
+ void (*apply_viewport)(int x, int y, int width, int height, bool origin_top_left, void* user_data);
+ void (*apply_scissor_rect)(int x, int y, int width, int height, bool origin_top_left, void* user_data);
+ void (*apply_pipeline)(sg_pipeline pip, void* user_data);
+ void (*apply_bindings)(const sg_bindings* bindings, void* user_data);
+ void (*apply_uniforms)(sg_shader_stage stage, int ub_index, const void* data, int num_bytes, void* user_data);
+ void (*draw)(int base_element, int num_elements, int num_instances, void* user_data);
+ void (*end_pass)(void* user_data);
+ void (*commit)(void* user_data);
+ void (*alloc_buffer)(sg_buffer result, void* user_data);
+ void (*alloc_image)(sg_image result, void* user_data);
+ void (*alloc_shader)(sg_shader result, void* user_data);
+ void (*alloc_pipeline)(sg_pipeline result, void* user_data);
+ void (*alloc_pass)(sg_pass result, void* user_data);
+ void (*init_buffer)(sg_buffer buf_id, const sg_buffer_desc* desc, void* user_data);
+ void (*init_image)(sg_image img_id, const sg_image_desc* desc, void* user_data);
+ void (*init_shader)(sg_shader shd_id, const sg_shader_desc* desc, void* user_data);
+ void (*init_pipeline)(sg_pipeline pip_id, const sg_pipeline_desc* desc, void* user_data);
+ void (*init_pass)(sg_pass pass_id, const sg_pass_desc* desc, void* user_data);
+ void (*fail_buffer)(sg_buffer buf_id, void* user_data);
+ void (*fail_image)(sg_image img_id, void* user_data);
+ void (*fail_shader)(sg_shader shd_id, void* user_data);
+ void (*fail_pipeline)(sg_pipeline pip_id, void* user_data);
+ void (*fail_pass)(sg_pass pass_id, void* user_data);
+ void (*push_debug_group)(const char* name, void* user_data);
+ void (*pop_debug_group)(void* user_data);
+ void (*err_buffer_pool_exhausted)(void* user_data);
+ void (*err_image_pool_exhausted)(void* user_data);
+ void (*err_shader_pool_exhausted)(void* user_data);
+ void (*err_pipeline_pool_exhausted)(void* user_data);
+ void (*err_pass_pool_exhausted)(void* user_data);
+ void (*err_context_mismatch)(void* user_data);
+ void (*err_pass_invalid)(void* user_data);
+ void (*err_draw_invalid)(void* user_data);
+ void (*err_bindings_invalid)(void* user_data);
+} sg_trace_hooks;
+
+/*
+ sg_desc
+
+ The sg_desc struct contains configuration values for sokol_gfx,
+ it is used as parameter to the sg_setup() call.
+
+ The default configuration is:
+
+ .buffer_pool_size: 128
+ .image_pool_size: 128
+ .shader_pool_size: 32
+ .pipeline_pool_size: 64
+ .pass_pool_size: 16
+ .context_pool_size: 16
+
+ GL specific:
+ .gl_force_gles2
+ if this is true the GL backend will act in "GLES2 fallback mode" even
+ when compiled with SOKOL_GLES3, this is useful to fall back
+ to traditional WebGL if a browser doesn't support a WebGL2 context
+
+ Metal specific:
+ (NOTE: All Objective-C object references are transferred through
+ a bridged (const void*) to sokol_gfx, which will use a unretained
+ bridged cast (__bridged id<xxx>) to retrieve the Objective-C
+ references back. Since the bridge cast is unretained, the caller
+ must hold a strong reference to the Objective-C object for the
+ duration of the sokol_gfx call!
+
+ .mtl_device
+ a pointer to the MTLDevice object
+ .mtl_renderpass_descriptor_cb
+ a C callback function to obtain the MTLRenderPassDescriptor for the
+ current frame when rendering to the default framebuffer, will be called
+ in sg_begin_default_pass()
+ .mtl_drawable_cb
+ a C callback function to obtain a MTLDrawable for the current
+ frame when rendering to the default framebuffer, will be called in
+ sg_end_pass() of the default pass
+ .mtl_global_uniform_buffer_size
+ the size of the global uniform buffer in bytes, this must be big
+ enough to hold all uniform block updates for a single frame,
+ the default value is 4 MByte (4 * 1024 * 1024)
+ .mtl_sampler_cache_size
+ the number of slots in the sampler cache, the Metal backend
+ will share texture samplers with the same state in this
+ cache, the default value is 64
+
+ D3D11 specific:
+ .d3d11_device
+ a pointer to the ID3D11Device object, this must have been created
+ before sg_setup() is called
+ .d3d11_device_context
+ a pointer to the ID3D11DeviceContext object
+ .d3d11_render_target_view_cb
+ a C callback function to obtain a pointer to the current
+ ID3D11RenderTargetView object of the default framebuffer,
+ this function will be called in sg_begin_pass() when rendering
+ to the default framebuffer
+ .d3d11_depth_stencil_view_cb
+ a C callback function to obtain a pointer to the current
+ ID3D11DepthStencilView object of the default framebuffer,
+ this function will be called in sg_begin_pass() when rendering
+ to the default framebuffer
+*/
+typedef struct sg_desc {
+ uint32_t _start_canary;
+ int buffer_pool_size;
+ int image_pool_size;
+ int shader_pool_size;
+ int pipeline_pool_size;
+ int pass_pool_size;
+ int context_pool_size;
+ /* GL specific */
+ bool gl_force_gles2;
+ /* Metal-specific */
+ const void* mtl_device;
+ const void* (*mtl_renderpass_descriptor_cb)(void);
+ const void* (*mtl_drawable_cb)(void);
+ int mtl_global_uniform_buffer_size;
+ int mtl_sampler_cache_size;
+ /* D3D11-specific */
+ const void* d3d11_device;
+ const void* d3d11_device_context;
+ const void* (*d3d11_render_target_view_cb)(void);
+ const void* (*d3d11_depth_stencil_view_cb)(void);
+ uint32_t _end_canary;
+} sg_desc;
+
/* setup and misc functions */
SOKOL_API_DECL void sg_setup(const sg_desc* desc);
SOKOL_API_DECL void sg_shutdown(void);
SOKOL_API_DECL bool sg_isvalid(void);
SOKOL_API_DECL bool sg_query_feature(sg_feature feature);
SOKOL_API_DECL void sg_reset_state_cache(void);
+SOKOL_API_DECL sg_trace_hooks sg_install_trace_hooks(const sg_trace_hooks* trace_hooks);
+SOKOL_API_DECL void sg_push_debug_group(const char* name);
+SOKOL_API_DECL void sg_pop_debug_group(void);
/* resource creation, destruction and updating */
SOKOL_API_DECL sg_buffer sg_make_buffer(const sg_buffer_desc* desc);
@@ -1690,6 +1804,14 @@ SOKOL_API_DECL void sg_apply_uniform_block(sg_shader_stage stage, int ub_index,
#define _SOKOL_UNUSED(x) (void)(x)
#endif
+#if defined(SOKOL_TRACE_HOOKS)
+#define _SG_TRACE_ARGS(fn, ...) if (_sg.hooks.fn) { _sg.hooks.fn(__VA_ARGS__, _sg.hooks.user_data); }
+#define _SG_TRACE_NOARGS(fn) if (_sg.hooks.fn) { _sg.hooks.fn(_sg.hooks.user_data); }
+#else
+#define _SG_TRACE_ARGS(fn, ...)
+#define _SG_TRACE_NOARGS(fn)
+#endif
+
/* default clear values */
#ifndef SG_DEFAULT_CLEAR_RED
#define SG_DEFAULT_CLEAR_RED (0.5f)
@@ -2556,15 +2678,19 @@ typedef enum {
_SG_VALIDATE_ABND_PIPELINE_EXISTS,
_SG_VALIDATE_ABND_PIPELINE_VALID,
_SG_VALIDATE_ABND_VBS,
+ _SG_VALIDATE_ABND_VB_EXISTS,
_SG_VALIDATE_ABND_VB_TYPE,
_SG_VALIDATE_ABND_VB_OVERFLOW,
_SG_VALIDATE_ABND_NO_IB,
_SG_VALIDATE_ABND_IB,
+ _SG_VALIDATE_ABND_IB_EXISTS,
_SG_VALIDATE_ABND_IB_TYPE,
_SG_VALIDATE_ABND_IB_OVERFLOW,
_SG_VALIDATE_ABND_VS_IMGS,
+ _SG_VALIDATE_ABND_VS_IMG_EXISTS,
_SG_VALIDATE_ABND_VS_IMG_TYPES,
_SG_VALIDATE_ABND_FS_IMGS,
+ _SG_VALIDATE_ABND_FS_IMG_EXISTS,
_SG_VALIDATE_ABND_FS_IMG_TYPES,
/* sg_apply_uniforms validation */
@@ -2614,6 +2740,9 @@ typedef struct {
#elif defined(SOKOL_D3D11)
_sg_d3d11_backend_t d3d11;
#endif
+ #if defined(SOKOL_TRACE_HOOKS)
+ sg_trace_hooks hooks;
+ #endif
} _sg_state_t;
static _sg_state_t _sg;
@@ -8364,15 +8493,19 @@ _SOKOL_PRIVATE const char* _sg_validate_string(_sg_validate_error_t err) {
case _SG_VALIDATE_ABND_PIPELINE_EXISTS: return "sg_apply_bindings: currently applied pipeline object no longer alive";
case _SG_VALIDATE_ABND_PIPELINE_VALID: return "sg_apply_bindings: currently applied pipeline object not in valid state";
case _SG_VALIDATE_ABND_VBS: return "sg_apply_bindings: number of vertex buffers doesn't match number of pipeline vertex layouts";
+ case _SG_VALIDATE_ABND_VB_EXISTS: return "sg_apply_bindings: vertex buffer no longer alive";
case _SG_VALIDATE_ABND_VB_TYPE: return "sg_apply_bindings: buffer in vertex buffer slot is not a SG_BUFFERTYPE_VERTEXBUFFER";
case _SG_VALIDATE_ABND_VB_OVERFLOW: return "sg_apply_bindings: buffer in vertex buffer slot is overflown";
case _SG_VALIDATE_ABND_NO_IB: return "sg_apply_bindings: pipeline object defines indexed rendering, but no index buffer provided";
case _SG_VALIDATE_ABND_IB: return "sg_apply_bindings: pipeline object defines non-indexed rendering, but index buffer provided";
+ case _SG_VALIDATE_ABND_IB_EXISTS: return "sg_apply_bindings: index buffer no longer alive";
case _SG_VALIDATE_ABND_IB_TYPE: return "sg_apply_bindings: buffer in index buffer slot is not a SG_BUFFERTYPE_INDEXBUFFER";
case _SG_VALIDATE_ABND_IB_OVERFLOW: return "sg_apply_bindings: buffer in index buffer slot is overflown";
case _SG_VALIDATE_ABND_VS_IMGS: return "sg_apply_bindings: vertex shader image count doesn't match sg_shader_desc";
+ case _SG_VALIDATE_ABND_VS_IMG_EXISTS: return "sg_apply_bindings: vertex shader image no longer alive";
case _SG_VALIDATE_ABND_VS_IMG_TYPES: return "sg_apply_bindings: one or more vertex shader image types don't match sg_shader_desc";
case _SG_VALIDATE_ABND_FS_IMGS: return "sg_apply_bindings: fragment shader image count doesn't match sg_shader_desc";
+ case _SG_VALIDATE_ABND_FS_IMG_EXISTS: return "sg_apply_bindings: fragment shader image no longer alive";
case _SG_VALIDATE_ABND_FS_IMG_TYPES: return "sg_apply_bindings: one or more fragment shader image types don't match sg_shader_desc";
/* sg_apply_uniforms */
@@ -8766,9 +8899,9 @@ _SOKOL_PRIVATE bool _sg_validate_apply_pipeline(sg_pipeline pip_id) {
#endif
}
-_SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bind) {
+_SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bindings) {
#if !defined(SOKOL_DEBUG)
- _SOKOL_UNUSED(bind);
+ _SOKOL_UNUSED(bindings);
return true;
#else
SOKOL_VALIDATE_BEGIN();
@@ -8785,12 +8918,12 @@ _SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bind) {
/* has expected vertex buffers, and vertex buffers still exist */
for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++) {
- if (bind->vertex_buffers[i].id != SG_INVALID_ID) {
+ if (bindings->vertex_buffers[i].id != SG_INVALID_ID) {
SOKOL_VALIDATE(pip->vertex_layout_valid[i], _SG_VALIDATE_ABND_VBS);
/* buffers in vertex-buffer-slots must be of type SG_BUFFERTYPE_VERTEXBUFFER */
- const _sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, bind->vertex_buffers[i].id);
- SOKOL_ASSERT(buf);
- if (buf->slot.state == SG_RESOURCESTATE_VALID) {
+ const _sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, bindings->vertex_buffers[i].id);
+ SOKOL_VALIDATE(buf != 0, _SG_VALIDATE_ABND_VB_EXISTS);
+ if (buf && buf->slot.state == SG_RESOURCESTATE_VALID) {
SOKOL_VALIDATE(SG_BUFFERTYPE_VERTEXBUFFER == buf->type, _SG_VALIDATE_ABND_VB_TYPE);
SOKOL_VALIDATE(!buf->append_overflow, _SG_VALIDATE_ABND_VB_OVERFLOW);
}
@@ -8804,17 +8937,17 @@ _SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bind) {
/* index buffer expected or not, and index buffer still exists */
if (pip->index_type == SG_INDEXTYPE_NONE) {
/* pipeline defines non-indexed rendering, but index buffer provided */
- SOKOL_VALIDATE(bind->index_buffer.id == SG_INVALID_ID, _SG_VALIDATE_ABND_IB);
+ SOKOL_VALIDATE(bindings->index_buffer.id == SG_INVALID_ID, _SG_VALIDATE_ABND_IB);
}
else {
/* pipeline defines indexed rendering, but no index buffer provided */
- SOKOL_VALIDATE(bind->index_buffer.id != SG_INVALID_ID, _SG_VALIDATE_ABND_NO_IB);
+ SOKOL_VALIDATE(bindings->index_buffer.id != SG_INVALID_ID, _SG_VALIDATE_ABND_NO_IB);
}
- if (bind->index_buffer.id != SG_INVALID_ID) {
+ if (bindings->index_buffer.id != SG_INVALID_ID) {
/* buffer in index-buffer-slot must be of type SG_BUFFERTYPE_INDEXBUFFER */
- const _sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, bind->index_buffer.id);
- SOKOL_ASSERT(buf);
- if (buf->slot.state == SG_RESOURCESTATE_VALID) {
+ const _sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, bindings->index_buffer.id);
+ SOKOL_VALIDATE(buf != 0, _SG_VALIDATE_ABND_IB_EXISTS);
+ if (buf && buf->slot.state == SG_RESOURCESTATE_VALID) {
SOKOL_VALIDATE(SG_BUFFERTYPE_INDEXBUFFER == buf->type, _SG_VALIDATE_ABND_IB_TYPE);
SOKOL_VALIDATE(!buf->append_overflow, _SG_VALIDATE_ABND_IB_OVERFLOW);
}
@@ -8823,11 +8956,11 @@ _SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bind) {
/* has expected vertex shader images */
for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
_sg_shader_stage_t* stage = &pip->shader->stage[SG_SHADERSTAGE_VS];
- if (bind->vs_images[i].id != SG_INVALID_ID) {
+ if (bindings->vs_images[i].id != SG_INVALID_ID) {
SOKOL_VALIDATE(i < stage->num_images, _SG_VALIDATE_ABND_VS_IMGS);
- const _sg_image_t* img = _sg_lookup_image(&_sg.pools, bind->vs_images[i].id);
- SOKOL_ASSERT(img);
- if (img->slot.state == SG_RESOURCESTATE_VALID) {
+ const _sg_image_t* img = _sg_lookup_image(&_sg.pools, bindings->vs_images[i].id);
+ SOKOL_VALIDATE(img != 0, _SG_VALIDATE_ABND_VS_IMG_EXISTS);
+ if (img && img->slot.state == SG_RESOURCESTATE_VALID) {
SOKOL_VALIDATE(img->type == stage->images[i].type, _SG_VALIDATE_ABND_VS_IMG_TYPES);
}
}
@@ -8839,11 +8972,11 @@ _SOKOL_PRIVATE bool _sg_validate_apply_bindings(const sg_bindings* bind) {
/* has expected fragment shader images */
for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
_sg_shader_stage_t* stage = &pip->shader->stage[SG_SHADERSTAGE_FS];
- if (bind->fs_images[i].id != SG_INVALID_ID) {
+ if (bindings->fs_images[i].id != SG_INVALID_ID) {
SOKOL_VALIDATE(i < stage->num_images, _SG_VALIDATE_ABND_FS_IMGS);
- const _sg_image_t* img = _sg_lookup_image(&_sg.pools, bind->fs_images[i].id);
- SOKOL_ASSERT(img);
- if (img->slot.state == SG_RESOURCESTATE_VALID) {
+ const _sg_image_t* img = _sg_lookup_image(&_sg.pools, bindings->fs_images[i].id);
+ SOKOL_VALIDATE(img != 0, _SG_VALIDATE_ABND_FS_IMG_EXISTS);
+ if (img && img->slot.state == SG_RESOURCESTATE_VALID) {
SOKOL_VALIDATE(img->type == stage->images[i].type, _SG_VALIDATE_ABND_FS_IMG_TYPES);
}
}
@@ -8942,82 +9075,8 @@ _SOKOL_PRIVATE bool _sg_validate_update_image(const _sg_image_t* img, const sg_i
#endif
}
-/*== PUBLIC API FUNCTIONS ====================================================*/
-SOKOL_API_IMPL void sg_setup(const sg_desc* desc) {
- SOKOL_ASSERT(desc);
- SOKOL_ASSERT((desc->_start_canary == 0) && (desc->_end_canary == 0));
- memset(&_sg, 0, sizeof(_sg));
- _sg_setup_pools(&_sg.pools, desc);
- _sg.frame_index = 1;
- _sg_setup_backend(desc);
- sg_setup_context();
- _sg.valid = true;
-}
-
-SOKOL_API_IMPL void sg_shutdown(void) {
- /* can only delete resources for the currently set context here, if multiple
- contexts are used, the app code must take care of properly releasing them
- (since only the app code can switch between 3D-API contexts)
- */
- if (_sg.active_context.id != SG_INVALID_ID) {
- _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, _sg.active_context.id);
- if (ctx) {
- _sg_destroy_all_resources(&_sg.pools, _sg.active_context.id);
- _sg_destroy_context(ctx);
- }
- }
- _sg_discard_backend();
- _sg_discard_pools(&_sg.pools);
- _sg.valid = false;
-}
-
-SOKOL_API_IMPL bool sg_isvalid(void) {
- return _sg.valid;
-}
-
-SOKOL_API_IMPL bool sg_query_feature(sg_feature f) {
- return _sg_query_feature(f);
-}
-
-SOKOL_API_IMPL sg_context sg_setup_context(void) {
- sg_context res;
- int slot_index = _sg_pool_alloc_index(&_sg.pools.context_pool);
- if (_SG_INVALID_SLOT_INDEX != slot_index) {
- res.id = _sg_slot_alloc(&_sg.pools.context_pool, &_sg.pools.contexts[slot_index].slot, slot_index);
- _sg_context_t* ctx = _sg_context_at(&_sg.pools, res.id);
- ctx->slot.state = _sg_create_context(ctx);
- SOKOL_ASSERT(ctx->slot.state == SG_RESOURCESTATE_VALID);
- _sg_activate_context(ctx);
- }
- else {
- /* pool is exhausted */
- res.id = SG_INVALID_ID;
- }
- _sg.active_context = res;
- return res;
-}
-
-SOKOL_API_IMPL void sg_discard_context(sg_context ctx_id) {
- _sg_destroy_all_resources(&_sg.pools, ctx_id.id);
- _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, ctx_id.id);
- if (ctx) {
- _sg_destroy_context(ctx);
- _sg_reset_context(ctx);
- _sg_pool_free_index(&_sg.pools.context_pool, _sg_slot_index(ctx_id.id));
- }
- _sg.active_context.id = SG_INVALID_ID;
- _sg_activate_context(0);
-}
-
-SOKOL_API_IMPL void sg_activate_context(sg_context ctx_id) {
- _sg.active_context = ctx_id;
- _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, ctx_id.id);
- /* NOTE: ctx can be 0 here if the context is no longer valid */
- _sg_activate_context(ctx);
-}
-
-/*-- allocate resource id ----------------------------------------------------*/
-SOKOL_API_IMPL sg_buffer sg_alloc_buffer(void) {
+/*== allocate/initialize resource private functions ==========================*/
+_SOKOL_PRIVATE sg_buffer _sg_alloc_buffer(void) {
sg_buffer res;
int slot_index = _sg_pool_alloc_index(&_sg.pools.buffer_pool);
if (_SG_INVALID_SLOT_INDEX != slot_index) {
@@ -9030,7 +9089,7 @@ SOKOL_API_IMPL sg_buffer sg_alloc_buffer(void) {
return res;
}
-SOKOL_API_IMPL sg_image sg_alloc_image(void) {
+_SOKOL_PRIVATE sg_image _sg_alloc_image(void) {
sg_image res;
int slot_index = _sg_pool_alloc_index(&_sg.pools.image_pool);
if (_SG_INVALID_SLOT_INDEX != slot_index) {
@@ -9043,7 +9102,7 @@ SOKOL_API_IMPL sg_image sg_alloc_image(void) {
return res;
}
-SOKOL_API_IMPL sg_shader sg_alloc_shader(void) {
+_SOKOL_PRIVATE sg_shader _sg_alloc_shader(void) {
sg_shader res;
int slot_index = _sg_pool_alloc_index(&_sg.pools.shader_pool);
if (_SG_INVALID_SLOT_INDEX != slot_index) {
@@ -9056,7 +9115,7 @@ SOKOL_API_IMPL sg_shader sg_alloc_shader(void) {
return res;
}
-SOKOL_API_IMPL sg_pipeline sg_alloc_pipeline(void) {
+_SOKOL_PRIVATE sg_pipeline _sg_alloc_pipeline(void) {
sg_pipeline res;
int slot_index = _sg_pool_alloc_index(&_sg.pools.pipeline_pool);
if (_SG_INVALID_SLOT_INDEX != slot_index) {
@@ -9069,7 +9128,7 @@ SOKOL_API_IMPL sg_pipeline sg_alloc_pipeline(void) {
return res;
}
-SOKOL_API_IMPL sg_pass sg_alloc_pass(void) {
+_SOKOL_PRIVATE sg_pass _sg_alloc_pass(void) {
sg_pass res;
int slot_index = _sg_pool_alloc_index(&_sg.pools.pass_pool);
if (_SG_INVALID_SLOT_INDEX != slot_index) {
@@ -9082,8 +9141,7 @@ SOKOL_API_IMPL sg_pass sg_alloc_pass(void) {
return res;
}
-/*-- initialize an allocated resource ----------------------------------------*/
-SOKOL_API_IMPL void sg_init_buffer(sg_buffer buf_id, const sg_buffer_desc* desc) {
+_SOKOL_PRIVATE void _sg_init_buffer(sg_buffer buf_id, const sg_buffer_desc* desc) {
SOKOL_ASSERT(buf_id.id != SG_INVALID_ID && desc);
_sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id.id);
SOKOL_ASSERT(buf && buf->slot.state == SG_RESOURCESTATE_ALLOC);
@@ -9097,7 +9155,7 @@ SOKOL_API_IMPL void sg_init_buffer(sg_buffer buf_id, const sg_buffer_desc* desc)
SOKOL_ASSERT((buf->slot.state == SG_RESOURCESTATE_VALID)||(buf->slot.state == SG_RESOURCESTATE_FAILED));
}
-SOKOL_API_IMPL void sg_init_image(sg_image img_id, const sg_image_desc* desc) {
+_SOKOL_PRIVATE void _sg_init_image(sg_image img_id, const sg_image_desc* desc) {
SOKOL_ASSERT(img_id.id != SG_INVALID_ID && desc);
_sg_image_t* img = _sg_lookup_image(&_sg.pools, img_id.id);
SOKOL_ASSERT(img && img->slot.state == SG_RESOURCESTATE_ALLOC);
@@ -9111,7 +9169,7 @@ SOKOL_API_IMPL void sg_init_image(sg_image img_id, const sg_image_desc* desc) {
SOKOL_ASSERT((img->slot.state == SG_RESOURCESTATE_VALID)||(img->slot.state == SG_RESOURCESTATE_FAILED));
}
-SOKOL_API_IMPL void sg_init_shader(sg_shader shd_id, const sg_shader_desc* desc) {
+_SOKOL_PRIVATE void _sg_init_shader(sg_shader shd_id, const sg_shader_desc* desc) {
SOKOL_ASSERT(shd_id.id != SG_INVALID_ID && desc);
_sg_shader_t* shd = _sg_lookup_shader(&_sg.pools, shd_id.id);
SOKOL_ASSERT(shd && shd->slot.state == SG_RESOURCESTATE_ALLOC);
@@ -9125,7 +9183,7 @@ SOKOL_API_IMPL void sg_init_shader(sg_shader shd_id, const sg_shader_desc* desc)
SOKOL_ASSERT((shd->slot.state == SG_RESOURCESTATE_VALID)||(shd->slot.state == SG_RESOURCESTATE_FAILED));
}
-SOKOL_API_IMPL void sg_init_pipeline(sg_pipeline pip_id, const sg_pipeline_desc* desc) {
+_SOKOL_PRIVATE void _sg_init_pipeline(sg_pipeline pip_id, const sg_pipeline_desc* desc) {
SOKOL_ASSERT(pip_id.id != SG_INVALID_ID && desc);
_sg_pipeline_t* pip = _sg_lookup_pipeline(&_sg.pools, pip_id.id);
SOKOL_ASSERT(pip && pip->slot.state == SG_RESOURCESTATE_ALLOC);
@@ -9141,7 +9199,7 @@ SOKOL_API_IMPL void sg_init_pipeline(sg_pipeline pip_id, const sg_pipeline_desc*
SOKOL_ASSERT((pip->slot.state == SG_RESOURCESTATE_VALID)||(pip->slot.state == SG_RESOURCESTATE_FAILED));
}
-SOKOL_API_IMPL void sg_init_pass(sg_pass pass_id, const sg_pass_desc* desc) {
+_SOKOL_PRIVATE void _sg_init_pass(sg_pass pass_id, const sg_pass_desc* desc) {
SOKOL_ASSERT(pass_id.id != SG_INVALID_ID && desc);
_sg_pass_t* pass = _sg_lookup_pass(&_sg.pools, pass_id.id);
SOKOL_ASSERT(pass && pass->slot.state == SG_RESOURCESTATE_ALLOC);
@@ -9174,6 +9232,149 @@ SOKOL_API_IMPL void sg_init_pass(sg_pass pass_id, const sg_pass_desc* desc) {
SOKOL_ASSERT((pass->slot.state == SG_RESOURCESTATE_VALID)||(pass->slot.state == SG_RESOURCESTATE_FAILED));
}
+/*== PUBLIC API FUNCTIONS ====================================================*/
+SOKOL_API_IMPL void sg_setup(const sg_desc* desc) {
+ SOKOL_ASSERT(desc);
+ SOKOL_ASSERT((desc->_start_canary == 0) && (desc->_end_canary == 0));
+ memset(&_sg, 0, sizeof(_sg));
+ _sg_setup_pools(&_sg.pools, desc);
+ _sg.frame_index = 1;
+ _sg_setup_backend(desc);
+ sg_setup_context();
+ _sg.valid = true;
+}
+
+SOKOL_API_IMPL void sg_shutdown(void) {
+ /* can only delete resources for the currently set context here, if multiple
+ contexts are used, the app code must take care of properly releasing them
+ (since only the app code can switch between 3D-API contexts)
+ */
+ if (_sg.active_context.id != SG_INVALID_ID) {
+ _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, _sg.active_context.id);
+ if (ctx) {
+ _sg_destroy_all_resources(&_sg.pools, _sg.active_context.id);
+ _sg_destroy_context(ctx);
+ }
+ }
+ _sg_discard_backend();
+ _sg_discard_pools(&_sg.pools);
+ _sg.valid = false;
+}
+
+SOKOL_API_IMPL bool sg_isvalid(void) {
+ return _sg.valid;
+}
+
+SOKOL_API_IMPL bool sg_query_feature(sg_feature f) {
+ bool res = _sg_query_feature(f);
+ _SG_TRACE_ARGS(query_feature, f, res);
+ return res;
+}
+
+SOKOL_API_IMPL sg_context sg_setup_context(void) {
+ sg_context res;
+ int slot_index = _sg_pool_alloc_index(&_sg.pools.context_pool);
+ if (_SG_INVALID_SLOT_INDEX != slot_index) {
+ res.id = _sg_slot_alloc(&_sg.pools.context_pool, &_sg.pools.contexts[slot_index].slot, slot_index);
+ _sg_context_t* ctx = _sg_context_at(&_sg.pools, res.id);
+ ctx->slot.state = _sg_create_context(ctx);
+ SOKOL_ASSERT(ctx->slot.state == SG_RESOURCESTATE_VALID);
+ _sg_activate_context(ctx);
+ }
+ else {
+ /* pool is exhausted */
+ res.id = SG_INVALID_ID;
+ }
+ _sg.active_context = res;
+ return res;
+}
+
+SOKOL_API_IMPL void sg_discard_context(sg_context ctx_id) {
+ _sg_destroy_all_resources(&_sg.pools, ctx_id.id);
+ _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, ctx_id.id);
+ if (ctx) {
+ _sg_destroy_context(ctx);
+ _sg_reset_context(ctx);
+ _sg_pool_free_index(&_sg.pools.context_pool, _sg_slot_index(ctx_id.id));
+ }
+ _sg.active_context.id = SG_INVALID_ID;
+ _sg_activate_context(0);
+}
+
+SOKOL_API_IMPL void sg_activate_context(sg_context ctx_id) {
+ _sg.active_context = ctx_id;
+ _sg_context_t* ctx = _sg_lookup_context(&_sg.pools, ctx_id.id);
+ /* NOTE: ctx can be 0 here if the context is no longer valid */
+ _sg_activate_context(ctx);
+}
+
+SOKOL_API_IMPL sg_trace_hooks sg_install_trace_hooks(const sg_trace_hooks* trace_hooks) {
+ SOKOL_ASSERT(trace_hooks);
+ #if defined(SOKOL_TRACE_HOOKS)
+ sg_trace_hooks old_hooks = _sg.hooks;
+ _sg.hooks = *trace_hooks;
+ #else
+ static sg_trace_hooks old_hooks;
+ SOKOL_LOG("sg_install_trace_hooks() called, but SG_TRACE_HOOKS is not defined!");
+ #endif
+ return old_hooks;
+}
+
+SOKOL_API_IMPL sg_buffer sg_alloc_buffer(void) {
+ sg_buffer res = _sg_alloc_buffer();
+ _SG_TRACE_ARGS(alloc_buffer, res);
+ return res;
+}
+
+SOKOL_API_IMPL sg_image sg_alloc_image(void) {
+ sg_image res = _sg_alloc_image();
+ _SG_TRACE_ARGS(alloc_image, res);
+ return res;
+}
+
+SOKOL_API_IMPL sg_shader sg_alloc_shader(void) {
+ sg_shader res = _sg_alloc_shader();
+ _SG_TRACE_ARGS(alloc_shader, res);
+ return res;
+}
+
+SOKOL_API_IMPL sg_pipeline sg_alloc_pipeline(void) {
+ sg_pipeline res = _sg_alloc_pipeline();
+ _SG_TRACE_ARGS(alloc_pipeline, res);
+ return res;
+}
+
+SOKOL_API_IMPL sg_pass sg_alloc_pass(void) {
+ sg_pass res = _sg_alloc_pass();
+ _SG_TRACE_ARGS(alloc_pass, res);
+ return res;
+}
+
+SOKOL_API_IMPL void sg_init_buffer(sg_buffer buf_id, const sg_buffer_desc* desc) {
+ _sg_init_buffer(buf_id, desc);
+ _SG_TRACE_ARGS(init_buffer, buf_id, desc);
+}
+
+SOKOL_API_IMPL void sg_init_image(sg_image img_id, const sg_image_desc* desc) {
+ _sg_init_image(img_id, desc);
+ _SG_TRACE_ARGS(init_image, img_id, desc);
+}
+
+SOKOL_API_IMPL void sg_init_shader(sg_shader shd_id, const sg_shader_desc* desc) {
+ _sg_init_shader(shd_id, desc);
+ _SG_TRACE_ARGS(init_shader, shd_id, desc);
+}
+
+SOKOL_API_IMPL void sg_init_pipeline(sg_pipeline pip_id, const sg_pipeline_desc* desc) {
+ _sg_init_pipeline(pip_id, desc);
+ _SG_TRACE_ARGS(init_pipeline, pip_id, desc);
+}
+
+SOKOL_API_IMPL void sg_init_pass(sg_pass pass_id, const sg_pass_desc* desc) {
+ _sg_init_pass(pass_id, desc);
+ _SG_TRACE_ARGS(init_pass, pass_id, desc);
+}
+
/*-- set allocated resource to failed state ----------------------------------*/
SOKOL_API_IMPL void sg_fail_buffer(sg_buffer buf_id) {
SOKOL_ASSERT(buf_id.id != SG_INVALID_ID);
@@ -9181,6 +9382,7 @@ SOKOL_API_IMPL void sg_fail_buffer(sg_buffer buf_id) {
SOKOL_ASSERT(buf && buf->slot.state == SG_RESOURCESTATE_ALLOC);
buf->slot.ctx_id = _sg.active_context.id;
buf->slot.state = SG_RESOURCESTATE_FAILED;
+ _SG_TRACE_ARGS(fail_buffer, buf_id);
}
SOKOL_API_IMPL void sg_fail_image(sg_image img_id) {
@@ -9189,6 +9391,7 @@ SOKOL_API_IMPL void sg_fail_image(sg_image img_id) {
SOKOL_ASSERT(img && img->slot.state == SG_RESOURCESTATE_ALLOC);
img->slot.ctx_id = _sg.active_context.id;
img->slot.state = SG_RESOURCESTATE_FAILED;
+ _SG_TRACE_ARGS(fail_image, img_id);
}
SOKOL_API_IMPL void sg_fail_shader(sg_shader shd_id) {
@@ -9197,6 +9400,7 @@ SOKOL_API_IMPL void sg_fail_shader(sg_shader shd_id) {
SOKOL_ASSERT(shd && shd->slot.state == SG_RESOURCESTATE_ALLOC);
shd->slot.ctx_id = _sg.active_context.id;
shd->slot.state = SG_RESOURCESTATE_FAILED;
+ _SG_TRACE_ARGS(fail_shader, shd_id);
}
SOKOL_API_IMPL void sg_fail_pipeline(sg_pipeline pip_id) {
@@ -9205,6 +9409,7 @@ SOKOL_API_IMPL void sg_fail_pipeline(sg_pipeline pip_id) {
SOKOL_ASSERT(pip && pip->slot.state == SG_RESOURCESTATE_ALLOC);
pip->slot.ctx_id = _sg.active_context.id;
pip->slot.state = SG_RESOURCESTATE_FAILED;
+ _SG_TRACE_ARGS(fail_pipeline, pip_id);
}
SOKOL_API_IMPL void sg_fail_pass(sg_pass pass_id) {
@@ -9213,92 +9418,113 @@ SOKOL_API_IMPL void sg_fail_pass(sg_pass pass_id) {
SOKOL_ASSERT(pass && pass->slot.state == SG_RESOURCESTATE_ALLOC);
pass->slot.ctx_id = _sg.active_context.id;
pass->slot.state = SG_RESOURCESTATE_FAILED;
+ _SG_TRACE_ARGS(fail_pass, pass_id);
}
/*-- get resource state */
SOKOL_API_IMPL sg_resource_state sg_query_buffer_state(sg_buffer buf_id) {
_sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id.id);
- return buf ? buf->slot.state : SG_RESOURCESTATE_INVALID;
+ sg_resource_state res = buf ? buf->slot.state : SG_RESOURCESTATE_INVALID;
+ _SG_TRACE_ARGS(query_buffer_state, buf_id, res);
+ return res;
}
SOKOL_API_IMPL sg_resource_state sg_query_image_state(sg_image img_id) {
_sg_image_t* img = _sg_lookup_image(&_sg.pools, img_id.id);
- return img ? img->slot.state : SG_RESOURCESTATE_INVALID;
+ sg_resource_state res = img ? img->slot.state : SG_RESOURCESTATE_INVALID;
+ _SG_TRACE_ARGS(query_image_state, img_id, res);
+ return res;
}
SOKOL_API_IMPL sg_resource_state sg_query_shader_state(sg_shader shd_id) {
_sg_shader_t* shd = _sg_lookup_shader(&_sg.pools, shd_id.id);
- return shd ? shd->slot.state : SG_RESOURCESTATE_INVALID;
+ sg_resource_state res = shd ? shd->slot.state : SG_RESOURCESTATE_INVALID;
+ _SG_TRACE_ARGS(query_shader_state, shd_id, res);
+ return res;
}
SOKOL_API_IMPL sg_resource_state sg_query_pipeline_state(sg_pipeline pip_id) {
_sg_pipeline_t* pip = _sg_lookup_pipeline(&_sg.pools, pip_id.id);
- return pip ? pip->slot.state : SG_RESOURCESTATE_INVALID;
+ sg_resource_state res = pip ? pip->slot.state : SG_RESOURCESTATE_INVALID;
+ _SG_TRACE_ARGS(query_pipeline_state, pip_id, res);
+ return res;
}
SOKOL_API_IMPL sg_resource_state sg_query_pass_state(sg_pass pass_id) {
_sg_pass_t* pass = _sg_lookup_pass(&_sg.pools, pass_id.id);
- return pass ? pass->slot.state : SG_RESOURCESTATE_INVALID;
+ sg_resource_state res = pass ? pass->slot.state : SG_RESOURCESTATE_INVALID;
+ _SG_TRACE_ARGS(query_pass_state, pass_id, res);
+ return res;
}
/*-- allocate and initialize resource ----------------------------------------*/
SOKOL_API_IMPL sg_buffer sg_make_buffer(const sg_buffer_desc* desc) {
SOKOL_ASSERT(desc);
- sg_buffer buf_id = sg_alloc_buffer();
+ sg_buffer buf_id = _sg_alloc_buffer();
if (buf_id.id != SG_INVALID_ID) {
- sg_init_buffer(buf_id, desc);
+ _sg_init_buffer(buf_id, desc);
}
else {
SOKOL_LOG("buffer pool exhausted!");
+ _SG_TRACE_NOARGS(err_buffer_pool_exhausted);
}
+ _SG_TRACE_ARGS(make_buffer, desc, buf_id);
return buf_id;
}
SOKOL_API_IMPL sg_image sg_make_image(const sg_image_desc* desc) {
SOKOL_ASSERT(desc);
- sg_image img_id = sg_alloc_image();
+ sg_image img_id = _sg_alloc_image();
if (img_id.id != SG_INVALID_ID) {
- sg_init_image(img_id, desc);
+ _sg_init_image(img_id, desc);
}
else {
SOKOL_LOG("image pool exhausted!");
+ _SG_TRACE_NOARGS(err_image_pool_exhausted);
}
+ _SG_TRACE_ARGS(make_image, desc, img_id);
return img_id;
}
SOKOL_API_IMPL sg_shader sg_make_shader(const sg_shader_desc* desc) {
SOKOL_ASSERT(desc);
- sg_shader shd_id = sg_alloc_shader();
+ sg_shader shd_id = _sg_alloc_shader();
if (shd_id.id != SG_INVALID_ID) {
- sg_init_shader(shd_id, desc);
+ _sg_init_shader(shd_id, desc);
}
else {
SOKOL_LOG("shader pool exhausted!");
+ _SG_TRACE_NOARGS(err_shader_pool_exhausted);
}
+ _SG_TRACE_ARGS(make_shader, desc, shd_id);
return shd_id;
}
SOKOL_API_IMPL sg_pipeline sg_make_pipeline(const sg_pipeline_desc* desc) {
SOKOL_ASSERT(desc);
- sg_pipeline pip_id = sg_alloc_pipeline();
+ sg_pipeline pip_id = _sg_alloc_pipeline();
if (pip_id.id != SG_INVALID_ID) {
- sg_init_pipeline(pip_id, desc);
+ _sg_init_pipeline(pip_id, desc);
}
else {
SOKOL_LOG("pipeline pool exhausted!");
+ _SG_TRACE_NOARGS(err_pipeline_pool_exhausted);
}
+ _SG_TRACE_ARGS(make_pipeline, desc, pip_id);
return pip_id;
}
SOKOL_API_IMPL sg_pass sg_make_pass(const sg_pass_desc* desc) {
SOKOL_ASSERT(desc);
- sg_pass pass_id = sg_alloc_pass();
+ sg_pass pass_id = _sg_alloc_pass();
if (pass_id.id != SG_INVALID_ID) {
- sg_init_pass(pass_id, desc);
+ _sg_init_pass(pass_id, desc);
}
else {
SOKOL_LOG("pass pool exhausted!");
+ _SG_TRACE_NOARGS(err_pass_pool_exhausted);
}
+ _SG_TRACE_ARGS(make_pass, desc, pass_id);
return pass_id;
}
@@ -9313,8 +9539,10 @@ SOKOL_API_IMPL void sg_destroy_buffer(sg_buffer buf_id) {
}
else {
SOKOL_LOG("sg_destroy_buffer: active context mismatch (must be same as for creation)");
+ _SG_TRACE_NOARGS(err_context_mismatch);
}
}
+ _SG_TRACE_ARGS(destroy_buffer, buf_id);
}
SOKOL_API_IMPL void sg_destroy_image(sg_image img_id) {
@@ -9327,8 +9555,10 @@ SOKOL_API_IMPL void sg_destroy_image(sg_image img_id) {
}
else {
SOKOL_LOG("sg_destroy_image: active context mismatch (must be same as for creation)");
+ _SG_TRACE_NOARGS(err_context_mismatch);
}
}
+ _SG_TRACE_ARGS(destroy_image, img_id);
}
SOKOL_API_IMPL void sg_destroy_shader(sg_shader shd_id) {
@@ -9341,8 +9571,10 @@ SOKOL_API_IMPL void sg_destroy_shader(sg_shader shd_id) {
}
else {
SOKOL_LOG("sg_destroy_shader: active context mismatch (must be same as for creation)");
+ _SG_TRACE_NOARGS(err_context_mismatch);
}
}
+ _SG_TRACE_ARGS(destroy_shader, shd_id);
}
SOKOL_API_IMPL void sg_destroy_pipeline(sg_pipeline pip_id) {
@@ -9355,8 +9587,10 @@ SOKOL_API_IMPL void sg_destroy_pipeline(sg_pipeline pip_id) {
}
else {
SOKOL_LOG("sg_destroy_pipeline: active context mismatch (must be same as for creation)");
+ _SG_TRACE_NOARGS(err_context_mismatch);
}
}
+ _SG_TRACE_ARGS(destroy_pipeline, pip_id);
}
SOKOL_API_IMPL void sg_destroy_pass(sg_pass pass_id) {
@@ -9369,8 +9603,10 @@ SOKOL_API_IMPL void sg_destroy_pass(sg_pass pass_id) {
}
else {
SOKOL_LOG("sg_destroy_pass: active context mismatch (must be same as for creation)");
+ _SG_TRACE_NOARGS(err_context_mismatch);
}
}
+ _SG_TRACE_ARGS(destroy_pass, pass_id);
}
SOKOL_API_IMPL void sg_begin_default_pass(const sg_pass_action* pass_action, int width, int height) {
@@ -9381,6 +9617,7 @@ SOKOL_API_IMPL void sg_begin_default_pass(const sg_pass_action* pass_action, int
_sg.cur_pass.id = SG_INVALID_ID;
_sg.pass_valid = true;
_sg_begin_pass(0, &pa, width, height);
+ _SG_TRACE_ARGS(begin_default_pass, pass_action, width, height);
}
SOKOL_API_IMPL void sg_begin_pass(sg_pass pass_id, const sg_pass_action* pass_action) {
@@ -9395,33 +9632,41 @@ SOKOL_API_IMPL void sg_begin_pass(sg_pass pass_id, const sg_pass_action* pass_ac
const int w = pass->color_atts[0].image->width;
const int h = pass->color_atts[0].image->height;
_sg_begin_pass(pass, &pa, w, h);
+ _SG_TRACE_ARGS(begin_pass, pass_id, pass_action);
}
else {
_sg.pass_valid = false;
+ _SG_TRACE_NOARGS(err_pass_invalid);
}
}
SOKOL_API_IMPL void sg_apply_viewport(int x, int y, int width, int height, bool origin_top_left) {
if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
return;
}
_sg_apply_viewport(x, y, width, height, origin_top_left);
+ _SG_TRACE_ARGS(apply_viewport, x, y, width, height, origin_top_left);
}
SOKOL_API_IMPL void sg_apply_scissor_rect(int x, int y, int width, int height, bool origin_top_left) {
if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
return;
}
_sg_apply_scissor_rect(x, y, width, height, origin_top_left);
+ _SG_TRACE_ARGS(apply_scissor_rect, x, y, width, height, origin_top_left);
}
SOKOL_API_IMPL void sg_apply_pipeline(sg_pipeline pip_id) {
_sg.bindings_valid = false;
if (!_sg_validate_apply_pipeline(pip_id)) {
_sg.next_draw_valid = false;
+ _SG_TRACE_NOARGS(err_draw_invalid);
return;
}
if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
return;
}
_sg.cur_pipeline = pip_id;
@@ -9430,13 +9675,15 @@ SOKOL_API_IMPL void sg_apply_pipeline(sg_pipeline pip_id) {
_sg.next_draw_valid = (SG_RESOURCESTATE_VALID == pip->slot.state);
SOKOL_ASSERT(pip->shader && (pip->shader->slot.id == pip->shader_id.id));
_sg_apply_pipeline(pip);
+ _SG_TRACE_ARGS(apply_pipeline, pip_id);
}
-SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
- SOKOL_ASSERT(bind);
- SOKOL_ASSERT((bind->_start_canary == 0) && (bind->_end_canary==0));
- if (!_sg_validate_apply_bindings(bind)) {
+SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bindings) {
+ SOKOL_ASSERT(bindings);
+ SOKOL_ASSERT((bindings->_start_canary == 0) && (bindings->_end_canary==0));
+ if (!_sg_validate_apply_bindings(bindings)) {
_sg.next_draw_valid = false;
+ _SG_TRACE_NOARGS(err_draw_invalid);
return;
}
_sg.bindings_valid = true;
@@ -9447,8 +9694,8 @@ SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
_sg_buffer_t* vbs[SG_MAX_SHADERSTAGE_BUFFERS] = { 0 };
int num_vbs = 0;
for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++, num_vbs++) {
- if (bind->vertex_buffers[i].id) {
- vbs[i] = _sg_lookup_buffer(&_sg.pools, bind->vertex_buffers[i].id);
+ if (bindings->vertex_buffers[i].id) {
+ vbs[i] = _sg_lookup_buffer(&_sg.pools, bindings->vertex_buffers[i].id);
SOKOL_ASSERT(vbs[i]);
_sg.next_draw_valid &= (SG_RESOURCESTATE_VALID == vbs[i]->slot.state);
_sg.next_draw_valid &= !vbs[i]->append_overflow;
@@ -9459,8 +9706,8 @@ SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
}
_sg_buffer_t* ib = 0;
- if (bind->index_buffer.id) {
- ib = _sg_lookup_buffer(&_sg.pools, bind->index_buffer.id);
+ if (bindings->index_buffer.id) {
+ ib = _sg_lookup_buffer(&_sg.pools, bindings->index_buffer.id);
SOKOL_ASSERT(ib);
_sg.next_draw_valid &= (SG_RESOURCESTATE_VALID == ib->slot.state);
_sg.next_draw_valid &= !ib->append_overflow;
@@ -9469,8 +9716,8 @@ SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
_sg_image_t* vs_imgs[SG_MAX_SHADERSTAGE_IMAGES] = { 0 };
int num_vs_imgs = 0;
for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++, num_vs_imgs++) {
- if (bind->vs_images[i].id) {
- vs_imgs[i] = _sg_lookup_image(&_sg.pools, bind->vs_images[i].id);
+ if (bindings->vs_images[i].id) {
+ vs_imgs[i] = _sg_lookup_image(&_sg.pools, bindings->vs_images[i].id);
SOKOL_ASSERT(vs_imgs[i]);
_sg.next_draw_valid &= (SG_RESOURCESTATE_VALID == vs_imgs[i]->slot.state);
}
@@ -9482,8 +9729,8 @@ SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
_sg_image_t* fs_imgs[SG_MAX_SHADERSTAGE_IMAGES] = { 0 };
int num_fs_imgs = 0;
for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++, num_fs_imgs++) {
- if (bind->fs_images[i].id) {
- fs_imgs[i] = _sg_lookup_image(&_sg.pools, bind->fs_images[i].id);
+ if (bindings->fs_images[i].id) {
+ fs_imgs[i] = _sg_lookup_image(&_sg.pools, bindings->fs_images[i].id);
SOKOL_ASSERT(fs_imgs[i]);
_sg.next_draw_valid &= (SG_RESOURCESTATE_VALID == fs_imgs[i]->slot.state);
}
@@ -9492,9 +9739,13 @@ SOKOL_API_IMPL void sg_apply_bindings(const sg_bindings* bind) {
}
}
if (_sg.next_draw_valid) {
- const int* vb_offsets = bind->vertex_buffer_offsets;
- int ib_offset = bind->index_buffer_offset;
+ const int* vb_offsets = bindings->vertex_buffer_offsets;
+ int ib_offset = bindings->index_buffer_offset;
_sg_apply_bindings(pip, vbs, vb_offsets, num_vbs, ib, ib_offset, vs_imgs, num_vs_imgs, fs_imgs, num_fs_imgs);
+ _SG_TRACE_ARGS(apply_bindings, bindings);
+ }
+ else {
+ _SG_TRACE_NOARGS(err_draw_invalid);
}
}
@@ -9504,12 +9755,18 @@ SOKOL_API_IMPL void sg_apply_uniforms(sg_shader_stage stage, int ub_index, const
SOKOL_ASSERT(data && (num_bytes > 0));
if (!_sg_validate_apply_uniforms(stage, ub_index, data, num_bytes)) {
_sg.next_draw_valid = false;
+ _SG_TRACE_NOARGS(err_draw_invalid);
return;
}
- if (!(_sg.pass_valid && _sg.next_draw_valid)) {
+ if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
return;
}
+ if (!_sg.next_draw_valid) {
+ _SG_TRACE_NOARGS(err_draw_invalid);
+ }
_sg_apply_uniforms(stage, ub_index, data, num_bytes);
+ _SG_TRACE_ARGS(apply_uniforms, stage, ub_index, data, num_bytes);
}
SOKOL_API_IMPL void sg_draw(int base_element, int num_elements, int num_instances) {
@@ -9518,52 +9775,64 @@ SOKOL_API_IMPL void sg_draw(int base_element, int num_elements, int num_instance
SOKOL_LOG("attempting to draw without resource bindings");
}
#endif
- if (!(_sg.pass_valid && _sg.bindings_valid && _sg.next_draw_valid)) {
+ if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
+ return;
+ }
+ if (!_sg.next_draw_valid) {
+ _SG_TRACE_NOARGS(err_draw_invalid);
+ return;
+ }
+ if (!_sg.bindings_valid) {
+ _SG_TRACE_NOARGS(err_bindings_invalid);
return;
}
_sg_draw(base_element, num_elements, num_instances);
+ _SG_TRACE_ARGS(draw, base_element, num_elements, num_instances);
}
SOKOL_API_IMPL void sg_end_pass(void) {
if (!_sg.pass_valid) {
+ _SG_TRACE_NOARGS(err_pass_invalid);
return;
}
_sg_end_pass();
_sg.cur_pass.id = SG_INVALID_ID;
_sg.cur_pipeline.id = SG_INVALID_ID;
_sg.pass_valid = false;
+ _SG_TRACE_NOARGS(end_pass);
}
SOKOL_API_IMPL void sg_commit(void) {
_sg_commit();
+ _SG_TRACE_NOARGS(commit);
_sg.frame_index++;
}
SOKOL_API_IMPL void sg_reset_state_cache(void) {
_sg_reset_state_cache();
+ _SG_TRACE_NOARGS(reset_state_cache);
}
SOKOL_API_IMPL void sg_update_buffer(sg_buffer buf_id, const void* data, int num_bytes) {
- if (num_bytes == 0) {
- return;
- }
_sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id.id);
- if (!(buf && buf->slot.state == SG_RESOURCESTATE_VALID)) {
- return;
- }
- if (_sg_validate_update_buffer(buf, data, num_bytes)) {
- SOKOL_ASSERT(num_bytes <= buf->size);
- /* only one update allowed per buffer and frame */
- SOKOL_ASSERT(buf->update_frame_index != _sg.frame_index);
- /* update and append on same buffer in same frame not allowed */
- SOKOL_ASSERT(buf->append_frame_index != _sg.frame_index);
- _sg_update_buffer(buf, data, num_bytes);
- buf->update_frame_index = _sg.frame_index;
+ if ((num_bytes > 0) && buf && (buf->slot.state == SG_RESOURCESTATE_VALID)) {
+ if (_sg_validate_update_buffer(buf, data, num_bytes)) {
+ SOKOL_ASSERT(num_bytes <= buf->size);
+ /* only one update allowed per buffer and frame */
+ SOKOL_ASSERT(buf->update_frame_index != _sg.frame_index);
+ /* update and append on same buffer in same frame not allowed */
+ SOKOL_ASSERT(buf->append_frame_index != _sg.frame_index);
+ _sg_update_buffer(buf, data, num_bytes);
+ buf->update_frame_index = _sg.frame_index;
+ }
}
+ _SG_TRACE_ARGS(update_buffer, buf_id, data, num_bytes);
}
SOKOL_API_IMPL int sg_append_buffer(sg_buffer buf_id, const void* data, int num_bytes) {
_sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id.id);
+ int result;
if (buf) {
/* rewind append cursor in a new frame */
if (buf->append_frame_index != _sg.frame_index) {
@@ -9585,34 +9854,42 @@ SOKOL_API_IMPL int sg_append_buffer(sg_buffer buf_id, const void* data, int num_
}
}
}
- return start_pos;
+ result = start_pos;
}
else {
/* FIXME: should we return -1 here? */
- return 0;
+ result = 0;
}
+ _SG_TRACE_ARGS(append_buffer, buf_id, data, num_bytes, result);
+ return result;
}
SOKOL_API_IMPL bool sg_query_buffer_overflow(sg_buffer buf_id) {
_sg_buffer_t* buf = _sg_lookup_buffer(&_sg.pools, buf_id.id);
- if (buf) {
- return buf->append_overflow;
- }
- else {
- return false;
- }
+ bool result = buf ? buf->append_overflow : false;
+ _SG_TRACE_ARGS(query_buffer_overflow, buf_id, result);
+ return result;
}
SOKOL_API_IMPL void sg_update_image(sg_image img_id, const sg_image_content* data) {
_sg_image_t* img = _sg_lookup_image(&_sg.pools, img_id.id);
- if (!(img && img->slot.state == SG_RESOURCESTATE_VALID)) {
- return;
- }
- if (_sg_validate_update_image(img, data)) {
- SOKOL_ASSERT(img->upd_frame_index != _sg.frame_index);
- _sg_update_image(img, data);
- img->upd_frame_index = _sg.frame_index;
+ if (img && img->slot.state == SG_RESOURCESTATE_VALID) {
+ if (_sg_validate_update_image(img, data)) {
+ SOKOL_ASSERT(img->upd_frame_index != _sg.frame_index);
+ _sg_update_image(img, data);
+ img->upd_frame_index = _sg.frame_index;
+ }
}
+ _SG_TRACE_ARGS(update_image, img_id, data);
+}
+
+SOKOL_API_IMPL void sg_push_debug_group(const char* name) {
+ SOKOL_ASSERT(name);
+ _SG_TRACE_ARGS(push_debug_group, name);
+}
+
+SOKOL_API_IMPL void sg_pop_debug_group(void) {
+ _SG_TRACE_NOARGS(pop_debug_group);
}
/*--- DEPRECATED ---*/
@@ -9621,19 +9898,19 @@ SOKOL_API_IMPL void sg_apply_draw_state(const sg_draw_state* ds) {
SOKOL_ASSERT(ds);
SOKOL_ASSERT((ds->_start_canary==0) && (ds->_end_canary==0));
sg_apply_pipeline(ds->pipeline);
- sg_bindings bind;
- memset(&bind, 0, sizeof(bind));
+ sg_bindings bindings;
+ memset(&bindings, 0, sizeof(bindings));
for (int i = 0; i < SG_MAX_SHADERSTAGE_BUFFERS; i++) {
- bind.vertex_buffers[i] = ds->vertex_buffers[i];
- bind.vertex_buffer_offsets[i] = ds->vertex_buffer_offsets[i];
+ bindings.vertex_buffers[i] = ds->vertex_buffers[i];
+ bindings.vertex_buffer_offsets[i] = ds->vertex_buffer_offsets[i];
}
- bind.index_buffer = ds->index_buffer;
- bind.index_buffer_offset = ds->index_buffer_offset;
+ bindings.index_buffer = ds->index_buffer;
+ bindings.index_buffer_offset = ds->index_buffer_offset;
for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
- bind.vs_images[i] = ds->vs_images[i];
- bind.fs_images[i] = ds->fs_images[i];
+ bindings.vs_images[i] = ds->vs_images[i];
+ bindings.fs_images[i] = ds->fs_images[i];
}
- sg_apply_bindings(&bind);
+ sg_apply_bindings(&bindings);
}
SOKOL_API_IMPL void sg_apply_uniform_block(sg_shader_stage stage, int ub_index, const void* data, int num_bytes) {
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 04:50:25 +0000