WebGPU + SDL3. Bug or not?

[ivan-enzhaev]

Dear ImGui supports WebGPU! It is very cool! I've built my app below for Wasm, EXE, and APK - it would not be possible with Vulkan to build for all three platforms from a single codebase.

View the Wasm-demo in the browser

Use this QR code to run the Wasm-demo above in your mobile browser:

Source code: imgui-webgpu-sdl3-cpp

But it does not work without of these changes in the imgui_impl_wgpu.cpp file:

Replace this code:

#if defined IMGUI_IMPL_WEBGPU_BACKEND_DAWN || defined IMGUI_IMPL_WEBGPU_BACKEND_WGVK
// Dawn renamed WGPUProgrammableStageDescriptor to WGPUComputeState (see: https://github.com/webgpu-native/webgpu-headers/pull/413)
// Using type alias until WGPU adopts the same naming convention (#8369)
using WGPUProgrammableStageDescriptor = WGPUComputeState;
#endif

With this one:

#if defined(IMGUI_IMPL_WEBGPU_BACKEND_WGPU)
#ifndef WGPUProgrammableStageDescriptor
typedef WGPUFragmentState WGPUProgrammableStageDescriptor;
#endif

#ifndef WGPUSurfaceGetCurrentTextureStatus_OutOfMemory
#define WGPUSurfaceGetCurrentTextureStatus_OutOfMemory WGPUSurfaceGetCurrentTextureStatus_Outdated
#endif

#ifndef WGPUSurfaceGetCurrentTextureStatus_DeviceLost
#define WGPUSurfaceGetCurrentTextureStatus_DeviceLost WGPUSurfaceGetCurrentTextureStatus_Timeout
#endif
#endif

Replace this code:

    WGPUVertexAttribute attribute_desc[] =
    {
#if defined IMGUI_IMPL_WEBGPU_BACKEND_DAWN || defined IMGUI_IMPL_WEBGPU_BACKEND_WGVK
        { nullptr, WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, pos), 0 },
        { nullptr, WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, uv),  1 },
        { nullptr, WGPUVertexFormat_Unorm8x4,  (uint64_t)offsetof(ImDrawVert, col), 2 },
#else
        { WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, pos), 0 },
        { WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, uv),  1 },
        { WGPUVertexFormat_Unorm8x4,  (uint64_t)offsetof(ImDrawVert, col), 2 },
#endif
    };

With this one:

    // Vertex input configuration
    WGPUVertexAttribute attribute_desc[] =
    {
        { nullptr, WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, pos), 0 },
        { nullptr, WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, uv),  1 },
        { nullptr, WGPUVertexFormat_Unorm8x4,  (uint64_t)offsetof(ImDrawVert, col), 2 },
    };

[ocornut]

Please don’t post in Discussions, it is very clearly stated everywhere.

if you want to provide changes to such an evolving backend please specify:

• exactly which wgpu implementation you are using. Include version numbers and build command-lines.

[ivan-enzhaev]

Let's target Desktop only, keeping imgui-1.92.9b/backends/imgui_impl_wgpu.cpp unchanged. I've removed the Android and Emscripten commands from CMakeLists.txt, as well as the platform #if checks from main.cpp.

Tools:

• wgpu-native 29.0.1.1 (https://github.com/gfx-rs/wgpu-native/releases)
• ImGUI 1.92.9b
• SDL3 3.4.14
• CMake 4.4.2
• MinGW GCC 16.2 (https://winlibs.com/)

CMakeLists.txt

set(CMAKE_BUILD_TYPE "Debug")

cmake_minimum_required(VERSION 3.21)
project(imgui-webgpu-sdl3-cpp-mingw)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# -----------------------------------------------------------------------------
# ImGui Path & Source Definitions
# -----------------------------------------------------------------------------
set(IMGUI_DIR "C:/libs/imgui-1.92.9b")

set(IMGUI_SOURCES
   ${IMGUI_DIR}/imgui.cpp
   ${IMGUI_DIR}/imgui_draw.cpp
   ${IMGUI_DIR}/imgui_tables.cpp
   ${IMGUI_DIR}/imgui_widgets.cpp
   ${IMGUI_DIR}/backends/imgui_impl_sdl3.cpp
   ${IMGUI_DIR}/backends/imgui_impl_wgpu.cpp
)

# -----------------------------------------------------------------------------
# Define Project Source Files
# -----------------------------------------------------------------------------
set(PROJECT_SOURCES
   src/main.cpp
   ${IMGUI_SOURCES}
)

# -----------------------------------------------------------------------------
# Target & Includes
# -----------------------------------------------------------------------------
add_executable(app)

target_sources(app PRIVATE ${PROJECT_SOURCES})

target_include_directories(app PRIVATE
   ${IMGUI_DIR}
   ${IMGUI_DIR}/backends
)

# -----------------------------------------------------------------------------
# Windows / MinGW Desktop Dependencies & Linking
# -----------------------------------------------------------------------------
add_compile_definitions(IMGUI_IMPL_WEBGPU_BACKEND_WGPU)

add_library(SDL3_Static STATIC IMPORTED)
set_target_properties(SDL3_Static PROPERTIES
   IMPORTED_LOCATION "C:/libs/sdl3-3.4.14-mingw/lib/libSDL3.a"
   INTERFACE_INCLUDE_DIRECTORIES "C:/libs/sdl3-3.4.14-mingw/include"
   INTERFACE_LINK_LIBRARIES "winmm;imm32;version;setupapi;dinput8"
)

add_library(wgpu_native STATIC IMPORTED)
set_target_properties(wgpu_native PROPERTIES
   IMPORTED_LOCATION "C:/libs/wgpu-29.0.1.1-mingw/lib/libwgpu_native.a"
   INTERFACE_INCLUDE_DIRECTORIES "C:/libs/wgpu-29.0.1.1-mingw/include"
   INTERFACE_LINK_LIBRARIES "ws2_32;userenv;ntdll;bcrypt;d3d12;dxgi"
)

target_link_libraries(app PRIVATE
   SDL3_Static
   wgpu_native
)

target_compile_options(app PRIVATE -Os)
target_link_options(app PRIVATE -static -s)

if (CMAKE_BUILD_TYPE STREQUAL "Debug")
   target_link_options(app PRIVATE -mconsole)
else()
   target_link_options(app PRIVATE -mwindows)
endif()

src/main.cpp

#define SDL_MAIN_USE_CALLBACKS 1

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <webgpu/webgpu.h>

#include "imgui.h"
#include "imgui_impl_sdl3.h"
#include "imgui_impl_wgpu.h"

#if defined(SDL_PLATFORM_WIN32)
#include <windows.h>
#endif

static SDL_Window *window = NULL;
static WGPUInstance instance = NULL;
static WGPUAdapter adapter = NULL;
static WGPUDevice device = NULL;
static WGPUQueue queue = NULL;
static WGPUSurface surface = NULL;
static WGPUSurfaceConfiguration config = { 0 };
static WGPURenderPipeline pipeline = NULL;

static WGPUBuffer uniform_buffer = NULL;
static WGPUBindGroup bind_group = NULL;

static bool is_configured = false;
static bool need_reconfigure = false;
static bool imgui_initialized = false;

static float triangle_color[3] = { 1.0f, 0.5f, 0.0f };
static float scale_val = 1.0f;

struct Uniforms {
    float scale;
    float aspect_ratio;
    float padding[2];
    float color[4];
};

static const int WIN_WIDTH = 1280;
static const int WIN_HEIGHT = 720;

const char *shader_code =
    "struct Uniforms {\n"
    "    scale: f32,\n"
    "    aspect_ratio: f32,\n"
    "    padding: vec2f,\n"
    "    color: vec4f,\n"
    "};\n"
    "@group(0) @binding(0) var<uniform> u: Uniforms;\n\n"
    "@vertex\n"
    "fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4f {\n"
    "    var pos = array<vec2f, 3>(\n"
    "        vec2f(0.0, 0.5),\n"
    "        vec2f(-0.5, -0.5),\n"
    "        vec2f(0.5, -0.5)\n"
    "    );\n"
    "    var p = pos[in_vertex_index] * u.scale;\n"
    "    return vec4f(p.x, p.y * u.aspect_ratio, 0.0, 1.0);\n"
    "}\n\n"
    "@fragment\n"
    "fn fs_main() -> @location(0) vec4f {\n"
    "    return u.color;\n"
    "}\n";

#ifdef __cplusplus
static inline WGPUStringView WGPU_STR(const char *s) {
    WGPUStringView view;
    view.data = s;
    view.length = (s != NULL) ? SDL_strlen(s) : WGPU_STRLEN;
    return view;
}
#else
#define WGPU_STR(s) (WGPUStringView){ .data = s, .length = (s != NULL) ? SDL_strlen(s) : WGPU_STRLEN }
#endif

static WGPUSurface CreateWGPUSurface(WGPUInstance inst, SDL_Window *win) {
#if defined(SDL_PLATFORM_WIN32)
    SDL_PropertiesID props = SDL_GetWindowProperties(win);
    HWND hwnd = (HWND)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
    HINSTANCE hinstance = (HINSTANCE)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER, NULL);

    WGPUSurfaceSourceWindowsHWND hwndSource = {
        .chain = { .sType = WGPUSType_SurfaceSourceWindowsHWND },
        .hinstance = hinstance,
        .hwnd = hwnd
    };

    WGPUSurfaceDescriptor desc = { .nextInChain = (WGPUChainedStruct *)&hwndSource };
    return wgpuInstanceCreateSurface(inst, &desc);
#else
    return NULL;
#endif
}

void handle_device_request(WGPURequestDeviceStatus status, WGPUDevice res, WGPUStringView message, void *userdata1, void *userdata2) {
    device = res;
}

void handle_adapter_request(WGPURequestAdapterStatus status, WGPUAdapter res, WGPUStringView message, void *userdata1, void *userdata2) {
    adapter = res;
    WGPURequestDeviceCallbackInfo deviceCallbackInfo = {
        .mode = WGPUCallbackMode_AllowSpontaneous,
        .callback = handle_device_request
    };
    wgpuAdapterRequestDevice(adapter, NULL, deviceCallbackInfo);
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) {
    SDL_SetHint(SDL_HINT_MAIN_CALLBACK_RATE, "60");
    SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "1");

    SDL_Init(SDL_INIT_VIDEO);

    window = SDL_CreateWindow("WebGPU Triangle + ImGui", WIN_WIDTH, WIN_HEIGHT, SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY);

    instance = wgpuCreateInstance(NULL);
    surface = CreateWGPUSurface(instance, window);

    WGPURequestAdapterOptions opt = { .compatibleSurface = surface };
    WGPURequestAdapterCallbackInfo adapterCallbackInfo = {
        .mode = WGPUCallbackMode_AllowSpontaneous,
        .callback = (WGPURequestAdapterCallback)handle_adapter_request
    };

    wgpuInstanceRequestAdapter(instance, &opt, adapterCallbackInfo);

    while (adapter == NULL || device == NULL) {
        SDL_Delay(1);
    }

    IMGUI_CHECKVERSION();
    ImGui::CreateContext();

    ImGuiIO &io = ImGui::GetIO();
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;

    ImGui::StyleColorsDark();

    float scale = SDL_GetWindowDisplayScale(window);
    if (scale <= 0.0f) scale = 1.0f;

    ImGui::GetStyle().ScaleAllSizes(scale);

    ImFontConfig font_cfg;
    font_cfg.SizePixels = 15.0f * scale;
    io.Fonts->AddFontDefault(&font_cfg);

    ImGui_ImplSDL3_InitForOther(window);

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {
    ImGui_ImplSDL3_ProcessEvent(event);

    if (event->type == SDL_EVENT_QUIT) {
        return SDL_APP_SUCCESS;
    }

    if (event->type == SDL_EVENT_WINDOW_RESIZED || event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
        need_reconfigure = true;
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate) {
    if (!is_configured || need_reconfigure) {
        int w = 0, h = 0;
        SDL_GetWindowSizeInPixels(window, &w, &h);

        config.width = (uint32_t)w;
        config.height = (uint32_t)h;

        if (!is_configured) {
            queue = wgpuDeviceGetQueue(device);

            WGPUSurfaceCapabilities caps = { 0 };
            wgpuSurfaceGetCapabilities(surface, adapter, &caps);

            WGPUTextureFormat surface_format = WGPUTextureFormat_Undefined;
            for (size_t i = 0; i < caps.formatCount; ++i) {
                if (caps.formats[i] == WGPUTextureFormat_BGRA8Unorm) {
                    surface_format = caps.formats[i];
                    break;
                }
                if (caps.formats[i] == WGPUTextureFormat_RGBA8Unorm) {
                    surface_format = caps.formats[i];
                }
            }

            if (surface_format == WGPUTextureFormat_Undefined) {
                surface_format = caps.formats[0];
            }

            WGPUPresentMode present_mode = (caps.presentModeCount > 0) ? caps.presentModes[0] : WGPUPresentMode_Fifo;

            config.device = device;
            config.format = surface_format;
            config.usage = WGPUTextureUsage_RenderAttachment;
            config.presentMode = present_mode;

            wgpuSurfaceCapabilitiesFreeMembers(caps);

            WGPUBufferDescriptor buffer_desc = {};
            buffer_desc.size = sizeof(Uniforms);
            buffer_desc.usage = WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst;
            uniform_buffer = wgpuDeviceCreateBuffer(device, &buffer_desc);

            WGPUBindGroupLayoutEntry bgl_entry = {};
            bgl_entry.binding = 0;
            bgl_entry.visibility = WGPUShaderStage_Vertex | WGPUShaderStage_Fragment;
            bgl_entry.buffer.type = WGPUBufferBindingType_Uniform;

            WGPUBindGroupLayoutDescriptor bgl_desc = {};
            bgl_desc.entryCount = 1;
            bgl_desc.entries = &bgl_entry;

            WGPUBindGroupLayout bind_group_layout = wgpuDeviceCreateBindGroupLayout(device, &bgl_desc);

            WGPUBindGroupEntry bg_entry = {};
            bg_entry.binding = 0;
            bg_entry.buffer = uniform_buffer;
            bg_entry.size = sizeof(Uniforms);

            WGPUBindGroupDescriptor bg_desc = {};
            bg_desc.layout = bind_group_layout;
            bg_desc.entryCount = 1;
            bg_desc.entries = &bg_entry;

            bind_group = wgpuDeviceCreateBindGroup(device, &bg_desc);

            WGPUPipelineLayoutDescriptor pipeline_layout_desc = {};
            pipeline_layout_desc.bindGroupLayoutCount = 1;
            pipeline_layout_desc.bindGroupLayouts = &bind_group_layout;

            WGPUPipelineLayout pipeline_layout = wgpuDeviceCreatePipelineLayout(device, &pipeline_layout_desc);

            WGPUShaderSourceWGSL wgsl_desc = { 0 };
            wgsl_desc.chain.sType = WGPUSType_ShaderSourceWGSL;
            wgsl_desc.code = WGPU_STR(shader_code);

            WGPUShaderModuleDescriptor shader_desc = { 0 };
            shader_desc.nextInChain = &wgsl_desc.chain;

            WGPUShaderModule shader_module = wgpuDeviceCreateShaderModule(device, &shader_desc);

            WGPUColorTargetState color_target = {
                .format = config.format,
                .writeMask = WGPUColorWriteMask_All
            };

            WGPUFragmentState fragment_state = {
                .module = shader_module,
                .entryPoint = WGPU_STR("fs_main"),
                .targetCount = 1,
                .targets = &color_target
            };

            WGPURenderPipelineDescriptor pipeline_desc = { 0 };
            pipeline_desc.layout = pipeline_layout;
            pipeline_desc.vertex.module = shader_module;
            pipeline_desc.vertex.entryPoint = WGPU_STR("vs_main");
            pipeline_desc.fragment = &fragment_state;
            pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
            pipeline_desc.multisample.count = 1;
            pipeline_desc.multisample.mask = 0xFFFFFFFF;

            pipeline = wgpuDeviceCreateRenderPipeline(device, &pipeline_desc);

            wgpuBindGroupLayoutRelease(bind_group_layout);
            wgpuPipelineLayoutRelease(pipeline_layout);
            wgpuShaderModuleRelease(shader_module);

            ImGui_ImplWGPU_InitInfo init_info = {};
            init_info.Device = device;
            init_info.NumFramesInFlight = 3;
            init_info.RenderTargetFormat = config.format;
            init_info.DepthStencilFormat = WGPUTextureFormat_Undefined;

            ImGui_ImplWGPU_Init(&init_info);

            imgui_initialized = true;
            is_configured = true;
        }

        wgpuSurfaceConfigure(surface, &config);
        need_reconfigure = false;
    }

    WGPUSurfaceTexture surfaceTexture = { 0 };
    wgpuSurfaceGetCurrentTexture(surface, &surfaceTexture);

    if (!surfaceTexture.texture) {
        return SDL_APP_CONTINUE;
    }

    ImGui_ImplWGPU_NewFrame();
    ImGui_ImplSDL3_NewFrame();
    ImGui::NewFrame();

    ImGuiIO &io = ImGui::GetIO();
    float scale = SDL_GetWindowDisplayScale(window);
    if (scale <= 0.0f) scale = 1.0f;

    float max_card_width = 360.0f * scale;
    float desired_width = (io.DisplaySize.x * 0.90f < max_card_width) ? io.DisplaySize.x * 0.90f : max_card_width;
    float pos_x = (io.DisplaySize.x - desired_width) * 0.5f;
    float pos_y = 20.0f * scale;

    ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
    ImGui::SetNextWindowSize(ImVec2(desired_width, 0.0f), ImGuiCond_Always);

    ImGui::Begin("WebGPU Controls", nullptr, ImGuiWindowFlags_NoSavedSettings);
    ImGui::PushItemWidth(-FLT_MIN);

    ImGui::Text("Scale");
    ImGui::SliderFloat("##Scale", &scale_val, 0.1f, 2.0f);
    ImGui::Spacing();

    ImGui::Text("Triangle Color");
    ImGui::ColorEdit3("##Triangle Color", triangle_color);
    ImGui::PopItemWidth();
    ImGui::Spacing();

    if (ImGui::Button("Reset Color", ImVec2(-FLT_MIN, 0.0f))) {
        triangle_color[0] = 1.0f;
        triangle_color[1] = 0.5f;
        triangle_color[2] = 0.0f;
    }

    ImGui::End();

    int w_pixels = 0, h_pixels = 0;
    SDL_GetWindowSizeInPixels(window, &w_pixels, &h_pixels);

    float aspect = (float)w_pixels / (float)h_pixels;

    Uniforms uniforms = {};
    uniforms.scale = scale_val;
    uniforms.aspect_ratio = aspect;
    uniforms.color[0] = triangle_color[0];
    uniforms.color[1] = triangle_color[1];
    uniforms.color[2] = triangle_color[2];
    uniforms.color[3] = 1.0f;

    wgpuQueueWriteBuffer(queue, uniform_buffer, 0, &uniforms, sizeof(Uniforms));

    WGPUTextureView view = wgpuTextureCreateView(surfaceTexture.texture, NULL);
    WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, NULL);

    WGPURenderPassColorAttachment colorAttachment = {
        .nextInChain = NULL,
        .view = view,
        .depthSlice = WGPU_DEPTH_SLICE_UNDEFINED,
        .resolveTarget = NULL,
        .loadOp = WGPULoadOp_Clear,
        .storeOp = WGPUStoreOp_Store,
        .clearValue = { 0.15, 0.15, 0.18, 1.0 }
    };

    WGPURenderPassDescriptor renderPassDesc = {
        .colorAttachmentCount = 1,
        .colorAttachments = &colorAttachment
    };

    WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &renderPassDesc);

    wgpuRenderPassEncoderSetPipeline(pass, pipeline);
    wgpuRenderPassEncoderSetBindGroup(pass, 0, bind_group, 0, NULL);
    wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);

    ImGui::Render();
    ImGui_ImplWGPU_RenderDrawData(ImGui::GetDrawData(), pass);

    wgpuRenderPassEncoderEnd(pass);

    WGPUCommandBuffer commandBuffer = wgpuCommandEncoderFinish(encoder, NULL);
    wgpuQueueSubmit(queue, 1, &commandBuffer);

    wgpuSurfacePresent(surface);

    wgpuCommandBufferRelease(commandBuffer);
    wgpuRenderPassEncoderRelease(pass);
    wgpuCommandEncoderRelease(encoder);
    wgpuTextureViewRelease(view);
    wgpuTextureRelease(surfaceTexture.texture);

    return SDL_APP_CONTINUE;
}

void SDL_AppQuit(void *appstate, SDL_AppResult result) {
    if (imgui_initialized) {
        ImGui_ImplWGPU_Shutdown();
    }

    ImGui_ImplSDL3_Shutdown();
    ImGui::DestroyContext();

    if (bind_group) wgpuBindGroupRelease(bind_group);
    if (uniform_buffer) wgpuBufferRelease(uniform_buffer);
    if (pipeline) wgpuRenderPipelineRelease(pipeline);
    if (surface) wgpuSurfaceUnconfigure(surface);
    if (queue) wgpuQueueRelease(queue);
    if (device) wgpuDeviceRelease(device);
    if (adapter) wgpuAdapterRelease(adapter);
    if (surface) wgpuSurfaceRelease(surface);
    if (instance) wgpuInstanceRelease(instance);
    if (window) SDL_DestroyWindow(window);

    SDL_Quit();
}

Errors:

>cmake --build .
-- Configuring done (0.0s)
-- Generating done (0.0s)
-- Build files have been written to: H:/projects/opengl/website/mingw/imgui-webgpu-sdl3-cpp-mingw/dist/win
[ 12%] Building CXX object CMakeFiles/app.dir/src/main.cpp.obj
[ 25%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/imgui.cpp.obj
[ 37%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/imgui_draw.cpp.obj
[ 50%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/imgui_tables.cpp.obj
[ 62%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/imgui_widgets.cpp.obj
[ 75%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/backends/imgui_impl_sdl3.cpp.obj
[ 87%] Building CXX object CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/backends/imgui_impl_wgpu.cpp.obj
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:319:8: error: 'WGPUProgrammableStageDescriptor' does not name a type
  319 | static WGPUProgrammableStageDescriptor ImGui_ImplWGPU_CreateShaderModuleWGSL(const char* wgsl_source)
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:359:8: error: 'WGPUProgrammableStageDescriptor' does not name a type
  359 | static WGPUProgrammableStageDescriptor ImGui_ImplWGPU_CreateShaderModuleSPIRV(const void* spirv_binary, size_t spirv_length)
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp: In function 'bool ImGui_ImplWGPU_CreateDeviceObjects()':
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:772:5: error: 'WGPUProgrammableStageDescriptor' was not declared in this scope
  772 |     WGPUProgrammableStageDescriptor vertex_shader_desc = ImGui_ImplWGPU_CreateShaderModuleWGSL(__shader_vert_wgsl);
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:773:10: error: 'vertex_shader_desc' was not declared in this scope
  773 |     if (!vertex_shader_desc.module) vertex_shader_desc = ImGui_ImplWGPU_CreateShaderModuleSPIRV(__shader_vert_spirv, sizeof(__shader_vert_spirv));
      |          ^~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:773:58: error: 'ImGui_ImplWGPU_CreateShaderModuleSPIRV' was not declared in this scope
  773 |     if (!vertex_shader_desc.module) vertex_shader_desc = ImGui_ImplWGPU_CreateShaderModuleSPIRV(__shader_vert_spirv, sizeof(__shader_vert_spirv));
      |                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:774:44: error: 'vertex_shader_desc' was not declared in this scope
  774 |     graphics_pipeline_desc.vertex.module = vertex_shader_desc.module;
      |                                            ^~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:785:11: error: cannot convert 'WGPUVertexFormat' to 'WGPUChainedStruct*' in initialization
  785 |         { WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, pos), 0 },
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
      |           |
      |           WGPUVertexFormat
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:786:11: error: cannot convert 'WGPUVertexFormat' to 'WGPUChainedStruct*' in initialization
  786 |         { WGPUVertexFormat_Float32x2, (uint64_t)offsetof(ImDrawVert, uv),  1 },
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
      |           |
      |           WGPUVertexFormat
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:787:11: error: cannot convert 'WGPUVertexFormat' to 'WGPUChainedStruct*' in initialization
  787 |         { WGPUVertexFormat_Unorm8x4,  (uint64_t)offsetof(ImDrawVert, col), 2 },
      |           ^~~~~~~~~~~~~~~~~~~~~~~~~
      |           |
      |           WGPUVertexFormat
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:801:36: error: expected ';' before 'pixel_shader_desc'
  801 |     WGPUProgrammableStageDescriptor pixel_shader_desc = ImGui_ImplWGPU_CreateShaderModuleWGSL(__shader_frag_wgsl);
      |                                    ^~~~~~~~~~~~~~~~~~
      |                                    ;
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:802:10: error: 'pixel_shader_desc' was not declared in this scope
  802 |     if (!pixel_shader_desc.module)  pixel_shader_desc = ImGui_ImplWGPU_CreateShaderModuleSPIRV(__shader_frag_spirv, sizeof(__shader_frag_spirv));
      |          ^~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:802:57: error: 'ImGui_ImplWGPU_CreateShaderModuleSPIRV' was not declared in this scope
  802 |     if (!pixel_shader_desc.module)  pixel_shader_desc = ImGui_ImplWGPU_CreateShaderModuleSPIRV(__shader_frag_spirv, sizeof(__shader_frag_spirv));
      |                                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:819:29: error: 'pixel_shader_desc' was not declared in this scope
  819 |     fragment_state.module = pixel_shader_desc.module;
      |                             ^~~~~~~~~~~~~~~~~
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp: In function 'bool ImGui_ImplWGPU_IsSurfaceStatusError(WGPUSurfaceGetCurrentTextureStatus)':
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:998:23: error: 'WGPUSurfaceGetCurrentTextureStatus_OutOfMemory' was not declared in this scope; did you mean 'WGPUSurfaceGetCurrentTextureStatus_Outdated'?
  998 |     return (status == WGPUSurfaceGetCurrentTextureStatus_OutOfMemory || status == WGPUSurfaceGetCurrentTextureStatus_DeviceLost);
      |                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                       WGPUSurfaceGetCurrentTextureStatus_Outdated
C:\libs\imgui-1.92.9b\backends\imgui_impl_wgpu.cpp:998:83: error: 'WGPUSurfaceGetCurrentTextureStatus_DeviceLost' was not declared in this scope; did you mean 'WGPUSurfaceGetCurrentTextureStatus_Timeout'?
  998 |     return (status == WGPUSurfaceGetCurrentTextureStatus_OutOfMemory || status == WGPUSurfaceGetCurrentTextureStatus_DeviceLost);
      |                                                                                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                                                                                   WGPUSurfaceGetCurrentTextureStatus_Timeout
mingw32-make[2]: *** [CMakeFiles\app.dir\build.make:169: CMakeFiles/app.dir/C_/libs/imgui-1.92.9b/backends/imgui_impl_wgpu.cpp.obj] Error 1
mingw32-make[1]: *** [CMakeFiles\Makefile2:86: CMakeFiles/app.dir/all] Error 2
mingw32-make: *** [Makefile:90: all] Error 2

Project: imgui-webgpu-sdl3-cpp-mingw.zip

[ivan-enzhaev]

I've created an issue here: #9532

[ocornut]

Implemented your fix as 6d1f88f. Thank you very much!

[ocornut]

It turns out that #9377 was a simpler fix so I also pushed 35a13e9.