aboutsummaryrefslogtreecommitdiff
path: root/util/sokol_gfx_imgui.h
diff options
context:
space:
mode:
Diffstat (limited to 'util/sokol_gfx_imgui.h')
-rw-r--r--util/sokol_gfx_imgui.h517
1 files changed, 244 insertions, 273 deletions
diff --git a/util/sokol_gfx_imgui.h b/util/sokol_gfx_imgui.h
index 5aea7ec1..24212f69 100644
--- a/util/sokol_gfx_imgui.h
+++ b/util/sokol_gfx_imgui.h
@@ -274,14 +274,12 @@ typedef struct sgimgui_shader_t {
sgimgui_str_t label;
sgimgui_str_t vs_entry;
sgimgui_str_t vs_d3d11_target;
- sgimgui_str_t vs_image_sampler_name[SG_MAX_SHADERSTAGE_IMAGESAMPLERPAIRS];
- sgimgui_str_t vs_uniform_name[SG_MAX_SHADERSTAGE_UBS][SG_MAX_UB_MEMBERS];
sgimgui_str_t fs_entry;
sgimgui_str_t fs_d3d11_target;
- sgimgui_str_t fs_image_sampler_name[SG_MAX_SHADERSTAGE_IMAGESAMPLERPAIRS];
- sgimgui_str_t fs_uniform_name[SG_MAX_SHADERSTAGE_UBS][SG_MAX_UB_MEMBERS];
- sgimgui_str_t attr_name[SG_MAX_VERTEX_ATTRIBUTES];
- sgimgui_str_t attr_sem_name[SG_MAX_VERTEX_ATTRIBUTES];
+ sgimgui_str_t glsl_image_sampler_name[SG_MAX_IMAGE_SAMPLER_PAIRS];
+ sgimgui_str_t glsl_uniform_name[SG_MAX_UNIFORMBLOCK_BINDSLOTS][SG_MAX_UNIFORMBLOCK_MEMBERS];
+ sgimgui_str_t attr_glsl_name[SG_MAX_VERTEX_ATTRIBUTES];
+ sgimgui_str_t attr_hlsl_sem_name[SG_MAX_VERTEX_ATTRIBUTES];
sg_shader_desc desc;
} sgimgui_shader_t;
@@ -489,8 +487,7 @@ typedef struct sgimgui_args_apply_bindings_t {
} sgimgui_args_apply_bindings_t;
typedef struct sgimgui_args_apply_uniforms_t {
- sg_shader_stage stage;
- int ub_index;
+ int ub_slot;
size_t data_size;
sg_pipeline pipeline; /* the pipeline which was active at this call */
size_t ubuf_pos; /* start of copied data in capture buffer */
@@ -858,6 +855,9 @@ _SOKOL_PRIVATE void igSameLine(float offset_from_start_x, float spacing) {
_SOKOL_PRIVATE void igPushID_Int(int int_id) {
return ImGui::PushID(int_id);
}
+_SOKOL_PRIVATE void igPushID_Str(const char* str_id) {
+ return ImGui::PushID(str_id);
+}
_SOKOL_PRIVATE void igPopID() {
return ImGui::PopID();
}
@@ -1475,9 +1475,9 @@ _SOKOL_PRIVATE const char* _sgimgui_facewinding_string(sg_face_winding fw) {
_SOKOL_PRIVATE const char* _sgimgui_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 "???";
+ case SG_SHADERSTAGE_VERTEX: return "SG_SHADERSTAGE_VERTEX";
+ case SG_SHADERSTAGE_FRAGMENT: return "SG_SHADERSTAGE_FRAGMENT";
+ default: return "???";
}
}
@@ -1611,73 +1611,58 @@ _SOKOL_PRIVATE void _sgimgui_shader_created(sgimgui_t* ctx, sg_shader res_id, in
shd->res_id = res_id;
shd->desc = *desc;
shd->label = _sgimgui_make_str(desc->label);
- if (shd->desc.vs.entry) {
- shd->vs_entry = _sgimgui_make_str(shd->desc.vs.entry);
- shd->desc.vs.entry = shd->vs_entry.buf;
- }
- if (shd->desc.fs.entry) {
- shd->fs_entry = _sgimgui_make_str(shd->desc.fs.entry);
- shd->desc.fs.entry = shd->fs_entry.buf;
- }
- if (shd->desc.vs.d3d11_target) {
- shd->vs_d3d11_target = _sgimgui_make_str(shd->desc.vs.d3d11_target);
- shd->desc.fs.d3d11_target = shd->vs_d3d11_target.buf;
- }
- if (shd->desc.fs.d3d11_target) {
- shd->fs_d3d11_target = _sgimgui_make_str(shd->desc.fs.d3d11_target);
- shd->desc.fs.d3d11_target = shd->fs_d3d11_target.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] = _sgimgui_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] = _sgimgui_make_str(ud->name);
- ud->name = shd->fs_uniform_name[i][j].buf;
+ if (shd->desc.vertex_func.entry) {
+ shd->vs_entry = _sgimgui_make_str(shd->desc.vertex_func.entry);
+ shd->desc.vertex_func.entry = shd->vs_entry.buf;
+ }
+ if (shd->desc.fragment_func.entry) {
+ shd->fs_entry = _sgimgui_make_str(shd->desc.fragment_func.entry);
+ shd->desc.fragment_func.entry = shd->fs_entry.buf;
+ }
+ if (shd->desc.vertex_func.d3d11_target) {
+ shd->vs_d3d11_target = _sgimgui_make_str(shd->desc.vertex_func.d3d11_target);
+ shd->desc.vertex_func.d3d11_target = shd->vs_d3d11_target.buf;
+ }
+ if (shd->desc.fragment_func.d3d11_target) {
+ shd->fs_d3d11_target = _sgimgui_make_str(shd->desc.fragment_func.d3d11_target);
+ shd->desc.fragment_func.d3d11_target = shd->fs_d3d11_target.buf;
+ }
+ for (int i = 0; i < SG_MAX_UNIFORMBLOCK_BINDSLOTS; i++) {
+ for (int j = 0; j < SG_MAX_UNIFORMBLOCK_MEMBERS; j++) {
+ sg_glsl_shader_uniform* su = &shd->desc.uniform_blocks[i].glsl_uniforms[j];
+ if (su->glsl_name) {
+ shd->glsl_uniform_name[i][j] = _sgimgui_make_str(su->glsl_name);
+ su->glsl_name = shd->glsl_uniform_name[i][j].buf;
}
}
}
- for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGESAMPLERPAIRS; i++) {
- if (shd->desc.vs.image_sampler_pairs[i].glsl_name) {
- shd->vs_image_sampler_name[i] = _sgimgui_make_str(shd->desc.vs.image_sampler_pairs[i].glsl_name);
- shd->desc.vs.image_sampler_pairs[i].glsl_name = shd->vs_image_sampler_name[i].buf;
- }
- }
- for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGESAMPLERPAIRS; i++) {
- if (shd->desc.fs.image_sampler_pairs[i].glsl_name) {
- shd->fs_image_sampler_name[i] = _sgimgui_make_str(shd->desc.fs.image_sampler_pairs[i].glsl_name);
- shd->desc.fs.image_sampler_pairs[i].glsl_name = shd->fs_image_sampler_name[i].buf;
+ for (int i = 0; i < SG_MAX_IMAGE_SAMPLER_PAIRS; i++) {
+ if (shd->desc.image_sampler_pairs[i].glsl_name) {
+ shd->glsl_image_sampler_name[i] = _sgimgui_make_str(shd->desc.image_sampler_pairs[i].glsl_name);
+ shd->desc.image_sampler_pairs[i].glsl_name = shd->glsl_image_sampler_name[i].buf;
}
}
- if (shd->desc.vs.source) {
- shd->desc.vs.source = _sgimgui_str_dup(&ctx->desc.allocator, shd->desc.vs.source);
+ if (shd->desc.vertex_func.source) {
+ shd->desc.vertex_func.source = _sgimgui_str_dup(&ctx->desc.allocator, shd->desc.vertex_func.source);
}
- if (shd->desc.vs.bytecode.ptr) {
- shd->desc.vs.bytecode.ptr = _sgimgui_bin_dup(&ctx->desc.allocator, shd->desc.vs.bytecode.ptr, shd->desc.vs.bytecode.size);
+ if (shd->desc.vertex_func.bytecode.ptr) {
+ shd->desc.vertex_func.bytecode.ptr = _sgimgui_bin_dup(&ctx->desc.allocator, shd->desc.vertex_func.bytecode.ptr, shd->desc.vertex_func.bytecode.size);
}
- if (shd->desc.fs.source) {
- shd->desc.fs.source = _sgimgui_str_dup(&ctx->desc.allocator, shd->desc.fs.source);
+ if (shd->desc.fragment_func.source) {
+ shd->desc.fragment_func.source = _sgimgui_str_dup(&ctx->desc.allocator, shd->desc.fragment_func.source);
}
- if (shd->desc.fs.bytecode.ptr) {
- shd->desc.fs.bytecode.ptr = _sgimgui_bin_dup(&ctx->desc.allocator, shd->desc.fs.bytecode.ptr, shd->desc.fs.bytecode.size);
+ if (shd->desc.fragment_func.bytecode.ptr) {
+ shd->desc.fragment_func.bytecode.ptr = _sgimgui_bin_dup(&ctx->desc.allocator, shd->desc.fragment_func.bytecode.ptr, shd->desc.fragment_func.bytecode.size);
}
for (int i = 0; i < SG_MAX_VERTEX_ATTRIBUTES; i++) {
- sg_shader_attr_desc* ad = &shd->desc.attrs[i];
- if (ad->name) {
- shd->attr_name[i] = _sgimgui_make_str(ad->name);
- ad->name = shd->attr_name[i].buf;
+ sg_shader_vertex_attr* va = &shd->desc.attrs[i];
+ if (va->glsl_name) {
+ shd->attr_glsl_name[i] = _sgimgui_make_str(va->glsl_name);
+ va->glsl_name = shd->attr_glsl_name[i].buf;
}
- if (ad->sem_name) {
- shd->attr_sem_name[i] = _sgimgui_make_str(ad->sem_name);
- ad->sem_name = shd->attr_sem_name[i].buf;
+ if (va->hlsl_sem_name) {
+ shd->attr_hlsl_sem_name[i] = _sgimgui_make_str(va->hlsl_sem_name);
+ va->hlsl_sem_name = shd->attr_hlsl_sem_name[i].buf;
}
}
}
@@ -1686,21 +1671,21 @@ _SOKOL_PRIVATE void _sgimgui_shader_destroyed(sgimgui_t* ctx, int slot_index) {
SOKOL_ASSERT((slot_index > 0) && (slot_index < ctx->shader_window.num_slots));
sgimgui_shader_t* shd = &ctx->shader_window.slots[slot_index];
shd->res_id.id = SG_INVALID_ID;
- if (shd->desc.vs.source) {
- _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.vs.source);
- shd->desc.vs.source = 0;
+ if (shd->desc.vertex_func.source) {
+ _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.vertex_func.source);
+ shd->desc.vertex_func.source = 0;
}
- if (shd->desc.vs.bytecode.ptr) {
- _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.vs.bytecode.ptr);
- shd->desc.vs.bytecode.ptr = 0;
+ if (shd->desc.vertex_func.bytecode.ptr) {
+ _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.vertex_func.bytecode.ptr);
+ shd->desc.vertex_func.bytecode.ptr = 0;
}
- if (shd->desc.fs.source) {
- _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.fs.source);
- shd->desc.fs.source = 0;
+ if (shd->desc.fragment_func.source) {
+ _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.fragment_func.source);
+ shd->desc.fragment_func.source = 0;
}
- if (shd->desc.fs.bytecode.ptr) {
- _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.fs.bytecode.ptr);
- shd->desc.fs.bytecode.ptr = 0;
+ if (shd->desc.fragment_func.bytecode.ptr) {
+ _sgimgui_free(&ctx->desc.allocator, (void*)shd->desc.fragment_func.bytecode.ptr);
+ shd->desc.fragment_func.bytecode.ptr = 0;
}
}
@@ -1970,10 +1955,9 @@ _SOKOL_PRIVATE sgimgui_str_t _sgimgui_capture_item_string(sgimgui_t* ctx, int in
break;
case SGIMGUI_CMD_APPLY_UNIFORMS:
- _sgimgui_snprintf(&str, "%d: sg_apply_uniforms(stage=%s, ub_index=%d, data.size=%d)",
+ _sgimgui_snprintf(&str, "%d: sg_apply_uniforms(ub_slot=%d, data.size=%d)",
index,
- _sgimgui_shaderstage_string(item->args.apply_uniforms.stage),
- item->args.apply_uniforms.ub_index,
+ item->args.apply_uniforms.ub_slot,
item->args.apply_uniforms.data_size);
break;
@@ -2563,7 +2547,7 @@ _SOKOL_PRIVATE void _sgimgui_apply_bindings(const sg_bindings* bindings, void* u
}
}
-_SOKOL_PRIVATE void _sgimgui_apply_uniforms(sg_shader_stage stage, int ub_index, const sg_range* data, void* user_data) {
+_SOKOL_PRIVATE void _sgimgui_apply_uniforms(int ub_slot, const sg_range* data, void* user_data) {
sgimgui_t* ctx = (sgimgui_t*) user_data;
SOKOL_ASSERT(ctx);
SOKOL_ASSERT(data);
@@ -2572,14 +2556,13 @@ _SOKOL_PRIVATE void _sgimgui_apply_uniforms(sg_shader_stage stage, int ub_index,
item->cmd = SGIMGUI_CMD_APPLY_UNIFORMS;
item->color = _SGIMGUI_COLOR_APPLY;
sgimgui_args_apply_uniforms_t* args = &item->args.apply_uniforms;
- args->stage = stage;
- args->ub_index = ub_index;
+ args->ub_slot = ub_slot;
args->data_size = data->size;
args->pipeline = ctx->cur_pipeline;
args->ubuf_pos = _sgimgui_capture_uniforms(ctx, data);
}
if (ctx->hooks.apply_uniforms) {
- ctx->hooks.apply_uniforms(stage, ub_index, data, ctx->hooks.user_data);
+ ctx->hooks.apply_uniforms(ub_slot, data, ctx->hooks.user_data);
}
}
@@ -3449,127 +3432,22 @@ _SOKOL_PRIVATE void _sgimgui_draw_sampler_panel(sgimgui_t* ctx, sg_sampler smp)
}
}
-_SOKOL_PRIVATE void _sgimgui_draw_shader_stage(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 (stage->images[i].used) {
- num_valid_images++;
- } else {
- break;
- }
- }
- int num_valid_samplers = 0;
- for (int i = 0; i < SG_MAX_SHADERSTAGE_SAMPLERS; i++) {
- if (stage->samplers[i].used) {
- num_valid_samplers++;
- } else {
- break;
- }
- }
- int num_valid_image_sampler_pairs = 0;
- for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGESAMPLERPAIRS; i++) {
- if (stage->image_sampler_pairs[i].used) {
- num_valid_image_sampler_pairs++;
- } else {
- break;
- }
- }
- int num_valid_storage_buffers = 0;
- for (int i = 0; i < SG_MAX_SHADERSTAGE_STORAGEBUFFERS; i++) {
- if (stage->storage_buffers[i].used) {
- num_valid_storage_buffers++;
- } else {
- break;
- }
- }
-
- if (num_valid_ubs > 0) {
- if (igTreeNode_Str("Uniform Blocks")) {
- for (int i = 0; i < num_valid_ubs; i++) {
- const sg_shader_uniform_block_desc* ub = &stage->uniform_blocks[i];
- igText("#%d: (size: %d layout: %s)\n", i, ub->size, _sgimgui_uniformlayout_string(ub->layout));
- 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 <= 1) {
- igText(" %s %s", _sgimgui_uniformtype_string(u->type), u->name ? u->name : "");
- } else {
- igText(" %s[%d] %s", _sgimgui_uniformtype_string(u->type), u->array_count, u->name ? u->name : "");
- }
- }
- }
- }
- igTreePop();
- }
- }
- if (num_valid_images > 0) {
- if (igTreeNode_Str("Images")) {
- for (int i = 0; i < num_valid_images; i++) {
- const sg_shader_image_desc* sid = &stage->images[i];
- igText("slot: %d\n multisampled: %s\n image_type: %s\n sample_type: %s",
- i,
- sid->multisampled ? "true" : "false",
- _sgimgui_imagetype_string(sid->image_type),
- _sgimgui_imagesampletype_string(sid->sample_type));
- }
- igTreePop();
- }
+_SOKOL_PRIVATE void _sgimgui_draw_shader_func(const char* title, const sg_shader_function* func) {
+ SOKOL_ASSERT(func);
+ igText("%s", title);
+ if (func->entry) {
+ igText(" entry: %s", func->entry);
}
- if (num_valid_samplers > 0) {
- if (igTreeNode_Str("Samplers")) {
- for (int i = 0; i < num_valid_samplers; i++) {
- const sg_shader_sampler_desc* ssd = &stage->samplers[i];
- igText("slot: %d\n sampler_type: %s", i, _sgimgui_samplertype_string(ssd->sampler_type));
- }
- igTreePop();
- }
- }
- if (num_valid_image_sampler_pairs > 0) {
- if (igTreeNode_Str("Image Sampler Pairs")) {
- for (int i = 0; i < num_valid_image_sampler_pairs; i++) {
- const sg_shader_image_sampler_pair_desc* sispd = &stage->image_sampler_pairs[i];
- igText("slot: %d\n image_slot: %d\n sampler_slot: %d\n glsl_name: %s\n",
- i,
- sispd->image_slot,
- sispd->sampler_slot,
- sispd->glsl_name ? sispd->glsl_name : "---");
- }
- igTreePop();
- }
+ if (func->d3d11_target) {
+ igText(" d3d11_target: %s", func->d3d11_target);
}
- if (num_valid_storage_buffers > 0) {
- if (igTreeNode_Str("Storage Buffers")) {
- for (int i = 0; i < num_valid_storage_buffers; i++) {
- const sg_shader_storage_buffer_desc* sbuf_desc = &stage->storage_buffers[i];
- igText("slot: %d\n readonly: %s\n", i, sbuf_desc->readonly ? "true" : "false");
- }
+ if (func->source) {
+ if (igTreeNode_Str("source:")) {
+ igText("%s", func->source);
igTreePop();
}
- }
- if (stage->entry) {
- igText("Entry: %s", stage->entry);
- }
- if (stage->d3d11_target) {
- igText("D3D11 Target: %s", stage->d3d11_target);
- }
- if (stage->source) {
- if (igTreeNode_Str("Source")) {
- igText("%s", stage->source);
- igTreePop();
- }
- } else if (stage->bytecode.ptr) {
- if (igTreeNode_Str("Byte Code")) {
+ } else if (func->bytecode.ptr) {
+ if (igTreeNode_Str("bytecode")) {
igText("Byte-code display currently not supported.");
igTreePop();
}
@@ -3587,24 +3465,148 @@ _SOKOL_PRIVATE void _sgimgui_draw_shader_panel(sgimgui_t* ctx, sg_shader shd) {
igSeparator();
if (igTreeNode_Str("Attrs")) {
for (int i = 0; i < SG_MAX_VERTEX_ATTRIBUTES; i++) {
- const sg_shader_attr_desc* a_desc = &shd_ui->desc.attrs[i];
- if (a_desc->name || a_desc->sem_index) {
+ const sg_shader_vertex_attr* a_desc = &shd_ui->desc.attrs[i];
+ if (a_desc->glsl_name || a_desc->hlsl_sem_name) {
igText("#%d:", i);
- igText(" Name: %s", a_desc->name ? a_desc->name : "---");
- igText(" Sem Name: %s", a_desc->sem_name ? a_desc->sem_name : "---");
- igText(" Sem Index: %d", a_desc->sem_index);
+ igText(" Name: %s", a_desc->glsl_name ? a_desc->glsl_name : "---");
+ igText(" Sem Name: %s", a_desc->hlsl_sem_name ? a_desc->hlsl_sem_name : "---");
+ igText(" Sem Index: %d", a_desc->hlsl_sem_index);
}
}
igTreePop();
}
- if (igTreeNode_Str("Vertex Shader Stage")) {
- _sgimgui_draw_shader_stage(&shd_ui->desc.vs);
- igTreePop();
+ int num_valid_ubs = 0;
+ for (int i = 0; i < SG_MAX_UNIFORMBLOCK_BINDSLOTS; i++) {
+ const sg_shader_uniform_block* ub = &shd_ui->desc.uniform_blocks[i];
+ if (ub->stage != SG_SHADERSTAGE_NONE) {
+ num_valid_ubs++;
+ }
}
- if (igTreeNode_Str("Fragment Shader Stage")) {
- _sgimgui_draw_shader_stage(&shd_ui->desc.fs);
- igTreePop();
+ int num_valid_images = 0;
+ for (int i = 0; i < SG_MAX_IMAGE_BINDSLOTS; i++) {
+ if (shd_ui->desc.images[i].stage != SG_SHADERSTAGE_NONE) {
+ num_valid_images++;
+ }
+ }
+ int num_valid_samplers = 0;
+ for (int i = 0; i < SG_MAX_SAMPLER_BINDSLOTS; i++) {
+ if (shd_ui->desc.samplers[i].stage != SG_SHADERSTAGE_NONE) {
+ num_valid_samplers++;
+ }
+ }
+ int num_valid_image_sampler_pairs = 0;
+ for (int i = 0; i < SG_MAX_IMAGE_SAMPLER_PAIRS; i++) {
+ if (shd_ui->desc.image_sampler_pairs[i].stage != SG_SHADERSTAGE_NONE) {
+ num_valid_image_sampler_pairs++;
+ }
+ }
+ int num_valid_storage_buffers = 0;
+ for (int i = 0; i < SG_MAX_STORAGEBUFFER_BINDSLOTS; i++) {
+ if (shd_ui->desc.storage_buffers[i].stage != SG_SHADERSTAGE_NONE) {
+ num_valid_storage_buffers++;
+ }
}
+ if (num_valid_ubs > 0) {
+ if (igTreeNode_Str("Uniform Blocks")) {
+ for (int i = 0; i < SG_MAX_UNIFORMBLOCK_BINDSLOTS; i++) {
+ const sg_shader_uniform_block* ub = &shd_ui->desc.uniform_blocks[i];
+ if (ub->stage == SG_SHADERSTAGE_NONE) {
+ continue;
+ }
+ igText("- slot: %d", i);
+ igText(" stage: %s", _sgimgui_shaderstage_string(ub->stage));
+ igText(" size: %d", ub->size);
+ igText(" layout: %s", _sgimgui_uniformlayout_string(ub->layout));
+ igText(" hlsl_register_b_n: %d", ub->hlsl_register_b_n);
+ igText(" msl_buffer_n: %d", ub->msl_buffer_n);
+ igText(" wgsl_group0_binding_n: %d", ub->wgsl_group0_binding_n);
+ igText(" glsl_uniforms:");
+ for (int j = 0; j < SG_MAX_UNIFORMBLOCK_MEMBERS; j++) {
+ const sg_glsl_shader_uniform* u = &ub->glsl_uniforms[j];
+ if (SG_UNIFORMTYPE_INVALID != u->type) {
+ if (u->array_count <= 1) {
+ igText(" %s %s", _sgimgui_uniformtype_string(u->type), u->glsl_name ? u->glsl_name : "");
+ } else {
+ igText(" %s[%d] %s", _sgimgui_uniformtype_string(u->type), u->array_count, u->glsl_name ? u->glsl_name : "");
+ }
+ }
+ }
+ }
+ igTreePop();
+ }
+ }
+ if (num_valid_storage_buffers > 0) {
+ if (igTreeNode_Str("Storage Buffers")) {
+ for (int i = 0; i < SG_MAX_STORAGEBUFFER_BINDSLOTS; i++) {
+ const sg_shader_storage_buffer* sbuf = &shd_ui->desc.storage_buffers[i];
+ if (sbuf->stage == SG_SHADERSTAGE_NONE) {
+ continue;
+ }
+ igText("- slot: %d", i);
+ igText(" stage: %s", _sgimgui_shaderstage_string(sbuf->stage));
+ igText(" readonly: %s", sbuf->readonly ? "true" : "false");
+ igText(" hlsl_register_t_n: %d", sbuf->hlsl_register_t_n);
+ igText(" msl_buffer_n: %d", sbuf->msl_buffer_n);
+ igText(" wgsl_group1_binding_n: %d", sbuf->wgsl_group1_binding_n);
+ igText(" glsl_binding_n: %d", sbuf->glsl_binding_n);
+ }
+ igTreePop();
+ }
+ }
+ if (num_valid_images > 0) {
+ if (igTreeNode_Str("Images")) {
+ for (int i = 0; i < SG_MAX_IMAGE_BINDSLOTS; i++) {
+ const sg_shader_image* sid = &shd_ui->desc.images[i];
+ if (sid->stage == SG_SHADERSTAGE_NONE) {
+ continue;
+ }
+ igText("- slot: %d", i);
+ igText(" stage: %s", _sgimgui_shaderstage_string(sid->stage));
+ igText(" image_type: %s", _sgimgui_imagetype_string(sid->image_type));
+ igText(" sample_type: %s", _sgimgui_imagesampletype_string(sid->sample_type));
+ igText(" multisampled: %s", sid->multisampled ? "true" : "false");
+ igText(" hlsl_register_t_n: %d", sid->hlsl_register_t_n);
+ igText(" msl_texture_n: %d", sid->msl_texture_n);
+ igText(" wgsl_group1_binding_n: %d", sid->wgsl_group1_binding_n);
+ }
+ igTreePop();
+ }
+ }
+ if (num_valid_samplers > 0) {
+ if (igTreeNode_Str("Samplers")) {
+ for (int i = 0; i < SG_MAX_SAMPLER_BINDSLOTS; i++) {
+ const sg_shader_sampler* ssd = &shd_ui->desc.samplers[i];
+ if (ssd->stage == SG_SHADERSTAGE_NONE) {
+ continue;
+ }
+ igText("- slot: %d", i);
+ igText(" stage: %s", _sgimgui_shaderstage_string(ssd->stage));
+ igText(" sampler_type: %s", _sgimgui_samplertype_string(ssd->sampler_type));
+ igText(" hlsl_register_s_n: %d", ssd->hlsl_register_s_n);
+ igText(" msl_sampler_n: %d", ssd->msl_sampler_n);
+ igText(" wgsl_group1_binding_n: %d", ssd->wgsl_group1_binding_n);
+ }
+ igTreePop();
+ }
+ }
+ if (num_valid_image_sampler_pairs > 0) {
+ if (igTreeNode_Str("Image Sampler Pairs")) {
+ for (int i = 0; i < SG_MAX_IMAGE_SAMPLER_PAIRS; i++) {
+ const sg_shader_image_sampler_pair* sispd = &shd_ui->desc.image_sampler_pairs[i];
+ if (sispd->stage == SG_SHADERSTAGE_NONE) {
+ continue;
+ }
+ igText("- slot: %d", i);
+ igText(" stage: %s", _sgimgui_shaderstage_string(sispd->stage));
+ igText(" image_slot: %d", sispd->image_slot);
+ igText(" sampler_slot: %d", sispd->sampler_slot);
+ igText(" glsl_name: %s", sispd->glsl_name ? sispd->glsl_name : "---");
+ }
+ igTreePop();
+ }
+ }
+ _sgimgui_draw_shader_func("Vertex Function", &shd_ui->desc.vertex_func);
+ _sgimgui_draw_shader_func("Fragment Function", &shd_ui->desc.fragment_func);
} else {
igText("Shader 0x%08X not valid!", shd.id);
}
@@ -3614,7 +3616,7 @@ _SOKOL_PRIVATE void _sgimgui_draw_shader_panel(sgimgui_t* ctx, sg_shader shd) {
_SOKOL_PRIVATE void _sgimgui_draw_vertex_layout_state(const sg_vertex_layout_state* layout) {
if (igTreeNode_Str("Buffers")) {
- for (int i = 0; i < SG_MAX_VERTEX_BUFFERS; i++) {
+ for (int i = 0; i < SG_MAX_VERTEXBUFFER_BINDSLOTS; i++) {
const sg_vertex_buffer_layout_state* l_state = &layout->buffers[i];
if (l_state->stride > 0) {
igText("#%d:", i);
@@ -3785,7 +3787,8 @@ _SOKOL_PRIVATE void _sgimgui_draw_attachments_panel(sgimgui_t* ctx, sg_attachmen
}
_SOKOL_PRIVATE void _sgimgui_draw_bindings_panel(sgimgui_t* ctx, const sg_bindings* bnd) {
- for (int i = 0; i < SG_MAX_VERTEX_BUFFERS; i++) {
+ igPushID_Str("bnd_vbufs");
+ for (int i = 0; i < SG_MAX_VERTEXBUFFER_BINDSLOTS; i++) {
sg_buffer buf = bnd->vertex_buffers[i];
if (buf.id != SG_INVALID_ID) {
igSeparator();
@@ -3795,10 +3798,10 @@ _SOKOL_PRIVATE void _sgimgui_draw_bindings_panel(sgimgui_t* ctx, const sg_bindin
_sgimgui_show_buffer(ctx, buf);
}
igText(" Offset: %d", bnd->vertex_buffer_offsets[i]);
- } else {
- break;
}
}
+ igPopID();
+ igPushID_Str("bnd_ibuf");
if (bnd->index_buffer.id != SG_INVALID_ID) {
sg_buffer buf = bnd->index_buffer;
if (buf.id != SG_INVALID_ID) {
@@ -3811,80 +3814,50 @@ _SOKOL_PRIVATE void _sgimgui_draw_bindings_panel(sgimgui_t* ctx, const sg_bindin
igText(" Offset: %d", bnd->index_buffer_offset);
}
}
- for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
- sg_image img = bnd->vs.images[i];
- if (img.id != SG_INVALID_ID) {
- igSeparator();
- igText("Vertex Stage Image Slot #%d:", i);
- igText(" Image: "); igSameLine(0,-1);
- if (_sgimgui_draw_image_link(ctx, img)) {
- _sgimgui_show_image(ctx, img);
- }
- } else {
- break;
- }
- }
- for (int i = 0; i < SG_MAX_SHADERSTAGE_SAMPLERS; i++) {
- sg_sampler smp = bnd->vs.samplers[i];
- if (smp.id != SG_INVALID_ID) {
- igSeparator();
- igText("Vertex Stage Sampler Slot #%d:", i);
- igText(" Sampler: "); igSameLine(0,-1);
- if (_sgimgui_draw_sampler_link(ctx, smp)) {
- _sgimgui_show_sampler(ctx, smp);
- }
- } else {
- break;
- }
- }
- for (int i = 0; i < SG_MAX_SHADERSTAGE_STORAGEBUFFERS; i++) {
- sg_buffer buf = bnd->vs.storage_buffers[i];
+ igPopID();
+ igPushID_Str("bnd_sbufs");
+ for (int i = 0; i < SG_MAX_STORAGEBUFFER_BINDSLOTS; i++) {
+ sg_buffer buf = bnd->storage_buffers[i];
if (buf.id != SG_INVALID_ID) {
igSeparator();
- igText("Vertex Stage Storage Buffer Slot #%d:", i);
+ igText("Storage Buffer Slot #%d:", i);
igText(" Buffer: "); igSameLine(0,-1);
if (_sgimgui_draw_buffer_link(ctx, buf)) {
_sgimgui_show_buffer(ctx, buf);
}
}
}
- for (int i = 0; i < SG_MAX_SHADERSTAGE_IMAGES; i++) {
- sg_image img = bnd->fs.images[i];
+ igPopID();
+ igPushID_Str("bnd_imgs");
+ for (int i = 0; i < SG_MAX_IMAGE_BINDSLOTS; i++) {
+ sg_image img = bnd->images[i];
if (img.id != SG_INVALID_ID) {
igSeparator();
- igText("Fragment Stage Image Slot #%d:", i);
+ igText("Image Slot #%d:", i);
igText(" Image: "); igSameLine(0,-1);
if (_sgimgui_draw_image_link(ctx, img)) {
_sgimgui_show_image(ctx, img);
}
}
}
- for (int i = 0; i < SG_MAX_SHADERSTAGE_SAMPLERS; i++) {
- sg_sampler smp = bnd->fs.samplers[i];
+ igPopID();
+ igPushID_Str("bnd_smps");
+ for (int i = 0; i < SG_MAX_SAMPLER_BINDSLOTS; i++) {
+ sg_sampler smp = bnd->samplers[i];
if (smp.id != SG_INVALID_ID) {
igSeparator();
- igText("Fragment Stage Sampler Slot #%d:", i);
+ igText("Sampler Slot #%d:", i);
igText(" Sampler: "); igSameLine(0,-1);
if (_sgimgui_draw_sampler_link(ctx, smp)) {
_sgimgui_show_sampler(ctx, smp);
}
}
}
- for (int i = 0; i < SG_MAX_SHADERSTAGE_STORAGEBUFFERS; i++) {
- sg_buffer buf = bnd->fs.storage_buffers[i];
- if (buf.id != SG_INVALID_ID) {
- igSeparator();
- igText("Fragment Stage Storage Buffer Slot #%d:", i);
- igText(" Buffer: "); igSameLine(0,-1);
- if (_sgimgui_draw_buffer_link(ctx, buf)) {
- _sgimgui_show_buffer(ctx, buf);
- }
- }
- }
+ igPopID();
}
_SOKOL_PRIVATE void _sgimgui_draw_uniforms_panel(sgimgui_t* ctx, const sgimgui_args_apply_uniforms_t* args) {
- SOKOL_ASSERT(args->ub_index < SG_MAX_VERTEX_BUFFERS);
+ SOKOL_ASSERT(args->ub_slot < SG_MAX_UNIFORMBLOCK_BINDSLOTS);
/* check if all the required information for drawing the structured uniform block content
is available, otherwise just render a generic hexdump
@@ -3900,12 +3873,10 @@ _SOKOL_PRIVATE void _sgimgui_draw_uniforms_panel(sgimgui_t* ctx, const sgimgui_a
}
sgimgui_shader_t* shd_ui = &ctx->shader_window.slots[_sgimgui_slot_index(pip_ui->desc.shader.id)];
SOKOL_ASSERT(shd_ui->res_id.id == pip_ui->desc.shader.id);
- const sg_shader_uniform_block_desc* ub_desc = (args->stage == SG_SHADERSTAGE_VS) ?
- &shd_ui->desc.vs.uniform_blocks[args->ub_index] :
- &shd_ui->desc.fs.uniform_blocks[args->ub_index];
+ const sg_shader_uniform_block* ub_desc = &shd_ui->desc.uniform_blocks[args->ub_slot];
SOKOL_ASSERT(args->data_size <= ub_desc->size);
bool draw_dump = false;
- if (ub_desc->uniforms[0].type == SG_UNIFORMTYPE_INVALID) {
+ if (ub_desc->glsl_uniforms[0].type == SG_UNIFORMTYPE_INVALID) {
draw_dump = true;
}
@@ -3915,16 +3886,16 @@ _SOKOL_PRIVATE void _sgimgui_draw_uniforms_panel(sgimgui_t* ctx, const sgimgui_a
const int32_t* uptri32 = (const int32_t*) uptrf;
if (!draw_dump) {
uint32_t u_off = 0;
- for (int i = 0; i < SG_MAX_UB_MEMBERS; i++) {
- const sg_shader_uniform_desc* ud = &ub_desc->uniforms[i];
+ for (int i = 0; i < SG_MAX_UNIFORMBLOCK_MEMBERS; i++) {
+ const sg_glsl_shader_uniform* ud = &ub_desc->glsl_uniforms[i];
if (ud->type == SG_UNIFORMTYPE_INVALID) {
break;
}
int num_items = (ud->array_count > 1) ? ud->array_count : 1;
if (num_items > 1) {
- igText("%d: %s %s[%d] =", i, _sgimgui_uniformtype_string(ud->type), ud->name?ud->name:"", ud->array_count);
+ igText("%d: %s %s[%d] =", i, _sgimgui_uniformtype_string(ud->type), ud->glsl_name?ud->glsl_name:"", ud->array_count);
} else {
- igText("%d: %s %s =", i, _sgimgui_uniformtype_string(ud->type), ud->name?ud->name:"");
+ igText("%d: %s %s =", i, _sgimgui_uniformtype_string(ud->type), ud->glsl_name?ud->glsl_name:"");
}
for (int item_index = 0; item_index < num_items; item_index++) {
const uint32_t u_size = _sgimgui_std140_uniform_size(ud->type, ud->array_count) / 4;
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 03:23:01 +0000