Skip to content

Port webgpu_app to render graph #251

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
MatzeOGH wants to merge 10 commits into
base: main
Choose a base branch
from
Open

Port webgpu_app to render graph #251

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
eedf92c
add RenderGraph
Jul 19, 2026
9bb2400
wire RenderGraph into webgpu_app
Jul 20, 2026
c3c1d2a
removed compile warnings in RenderGraphPanel.cpp
Jul 27, 2026
58132cd
docs rewrite
Jul 31, 2026
3f66f39
removal of legacy rendering code 1/N
Aug 6, 2026
2e9bb35
cleanup of rendering implementation
Aug 7, 2026
27d861d
pipe swapchain size through paint() api
Aug 7, 2026
6ca2849
code dedup in rendergraph and RenderGraphPanel
Aug 7, 2026
02009bc
removed a warning int to uint missmatch
Aug 7, 2026
416951c
fixed a 0.5Mb/s memory leak
Aug 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
153 changes: 49 additions & 104 deletions apps/webgpu_app/App.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,7 @@
#include <nucleus/timing/CpuTimer.h>
#include <webgpu/engine/Context.h>
#include <webgpu/engine/tile_mesh/TileMeshRenderer.h>
#include "webgpu/base/RenderGraph.h"

namespace webgpu_app {

Expand Down Expand Up @@ -178,13 +179,13 @@ void App::poll_events()

void App::render()
{
m_cputimer->start();

// Do nothing, this checks for ongoing asynchronous operations and call their callbacks

WGPUSurfaceTexture surface_texture;
wgpuSurfaceGetCurrentTexture(m_surface, &surface_texture);

m_cputimer->start();

if (surface_texture.status != WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal
&& surface_texture.status != WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal) {
// skip frame (?)
Expand Down Expand Up @@ -216,27 +217,46 @@ void App::render()
m_gputimer->start(encoder);

m_frame_count++;
if (m_webgpu_window->needs_redraw() || m_force_repaint || m_force_repaint_once) {
m_webgpu_window->paint(m_framebuffer.get(), encoder);

bool needsRedraw = m_webgpu_window->needs_redraw() || m_force_repaint || m_force_repaint_once;
m_force_repaint_once = false;

// Only run the render graph when something changed
if (needsRedraw) {
m_repaint_count++;
m_force_repaint_once = false;
}

{
webgpu::raii::RenderPassEncoder render_pass(encoder, surface_texture_view, nullptr);
wgpuRenderPassEncoderSetPipeline(render_pass.handle(), m_gui_pipeline.get()->pipeline().handle());
wgpuRenderPassEncoderSetBindGroup(render_pass.handle(), 0, m_gui_bind_group->handle(), 0, nullptr);
wgpuRenderPassEncoderDraw(render_pass.handle(), 3, 1, 0, 0);
webgpu::rg::begin_frame(m_context->graph_allocator);
webgpu::rg::RenderGraph* rg = webgpu::rg::start_recording(m_context->graph_allocator);
g_render_graph = rg; // pipes the rg to the RenderGraphPanel

auto scene = rg->import_texture("scene",
{
.view = m_scene_texture_view->handle(),
.size = { m_viewport_size.x, m_viewport_size.y, 1 },
.format = m_surface_texture_format,
.texture = m_scene_texture->handle(),
});

m_webgpu_window->paint(rg, scene, {m_viewport_size.x, m_viewport_size.y});

// We add the GUI drawing commands to the render pass
m_gui_manager->render(render_pass.handle());
for (webgpu::rg::ErrorMessage* error = rg->compile(); error; error = error->next)
qCritical("%.*s", static_cast<int>(error->message.length), error->message.data);

rg->execute(m_device, m_queue, encoder, false);
rg->collect_gpu_timings();

webgpu::rg::end_frame(m_context->graph_allocator);
}


m_gui_manager->render(encoder, surface_texture_view, m_scene_texture_view->create_bind_group_entry(0));

if (webgpu::isTimingSupported())
m_gputimer->stop(encoder);

wgpuTextureViewRelease(surface_texture_view);

wgpuTextureRelease(surface_texture.texture);

WGPUCommandBufferDescriptor cmd_buffer_descriptor {};
cmd_buffer_descriptor.label = WGPUStringView { .data = "Command buffer", .length = WGPU_STRLEN };
WGPUCommandBuffer command = wgpuCommandEncoderFinish(encoder, &cmd_buffer_descriptor);
Expand Down Expand Up @@ -279,7 +299,7 @@ void App::start()
connect(m_camera_controller.get(), &nucleus::camera::Controller::definition_changed, m_context->ortho_scheduler(), &nucleus::tile::Scheduler::update_camera);
connect(m_camera_controller.get(), &nucleus::camera::Controller::definition_changed, m_context->cloud_scheduler(), &nucleus::tile::Scheduler::update_camera);
connect(m_camera_controller.get(), &nucleus::camera::Controller::definition_changed, m_webgpu_window.get(), &webgpu_engine::Window::update_camera);

connect(m_context->geometry_scheduler(), &nucleus::tile::GeometryScheduler::gpu_tiles_updated, m_webgpu_window.get(), &webgpu_engine::Window::update_requested);
connect(m_context->ortho_scheduler(), &nucleus::tile::TextureScheduler::gpu_tiles_updated, m_webgpu_window.get(), &webgpu_engine::Window::update_requested);
connect(m_context->cloud_scheduler(), &nucleus::tile::Texture3DScheduler::gpu_tiles_updated, m_webgpu_window.get(), &webgpu_engine::Window::update_requested);
Expand Down Expand Up @@ -312,77 +332,6 @@ void App::start()
m_camera_controller->set_model_matrix(new_definition);
}

qDebug() << "Create GUI Pipeline...";
m_gui_ubo = std::make_unique<webgpu::raii::RawBuffer<App::GuiPipelineUBO>>(m_device, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst, 1, "gui ubo");
m_gui_ubo->write(m_queue, &m_gui_ubo_data);

webgpu::FramebufferFormat format {};
format.color_formats.emplace_back(m_surface_texture_format);

WGPUBindGroupLayoutEntry backbuffer_texture_entry {};
backbuffer_texture_entry.binding = 0;
backbuffer_texture_entry.visibility = WGPUShaderStage_Fragment;
backbuffer_texture_entry.texture.sampleType = WGPUTextureSampleType_Float;
backbuffer_texture_entry.texture.viewDimension = WGPUTextureViewDimension_2D;

WGPUBindGroupLayoutEntry gui_ubo_entry = {};
gui_ubo_entry.binding = 1;
gui_ubo_entry.visibility = WGPUShaderStage_Fragment;
gui_ubo_entry.buffer.type = WGPUBufferBindingType_Uniform;
gui_ubo_entry.buffer.minBindingSize = sizeof(App::GuiPipelineUBO);

m_gui_bind_group_layout = std::make_unique<webgpu::raii::BindGroupLayout>(
m_device, std::vector<WGPUBindGroupLayoutEntry> { backbuffer_texture_entry, gui_ubo_entry }, "gui bind group layout");

const char preprocessed_code[] = R"(
@group(0) @binding(0) var backbuffer_texture : texture_2d<f32>;
@group(0) @binding(1) var<uniform> gui_ubo : vec2f;

struct VertexOut {
@builtin(position) position : vec4f,
@location(0) texcoords : vec2f
}

@vertex
fn vertexMain(@builtin(vertex_index) vertex_index : u32) -> VertexOut {
const VERTICES = array(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));
var vertex_out : VertexOut;
vertex_out.position = vec4(VERTICES[vertex_index], 0.0, 1.0);
vertex_out.texcoords = vec2(0.5, -0.5) * vertex_out.position.xy + vec2(0.5);
return vertex_out;
}

@fragment
fn fragmentMain(vertex_out : VertexOut) -> @location(0) vec4f {
let tci : vec2<u32> = vec2u(vertex_out.texcoords * gui_ubo);
var backbuffer_color = textureLoad(backbuffer_texture, tci, 0);
return backbuffer_color;
}
)";

WGPUShaderSourceWGSL wgsl_desc {};
wgsl_desc.chain.next = nullptr;
wgsl_desc.chain.sType = WGPUSType_ShaderSourceWGSL;
wgsl_desc.code = WGPUStringView {
.data = preprocessed_code,
.length = WGPU_STRLEN,
};
WGPUShaderModuleDescriptor shader_module_desc {};
shader_module_desc.label = WGPUStringView { .data = "Gui Shader Module", .length = WGPU_STRLEN };
shader_module_desc.nextInChain = &wgsl_desc.chain;
auto shader_module = std::make_unique<webgpu::raii::ShaderModule>(m_device, shader_module_desc);

m_gui_pipeline = std::make_unique<webgpu::raii::GenericRenderPipeline>(m_device,
*shader_module,
*shader_module,
std::vector<webgpu::util::SingleVertexBufferInfo> {},
format,
std::vector<const webgpu::raii::BindGroupLayout*> { m_gui_bind_group_layout.get() });

m_gui_bind_group = std::make_unique<webgpu::raii::BindGroup>(m_device,
*m_gui_bind_group_layout.get(),
std::initializer_list<WGPUBindGroupEntry> { m_framebuffer->color_texture_view(0).create_bind_group_entry(0), m_gui_ubo->create_bind_group_entry(1) });

m_timer_manager = std::make_unique<webgpu::timing::GuiTimerManager>();
m_gui_manager->init(m_sdl_window, m_device, m_surface_texture_format, WGPUTextureFormat_Undefined);

Expand Down Expand Up @@ -455,24 +404,18 @@ void App::handle_shortcuts(QKeyCombination key)

void App::schedule_update() { m_force_repaint_once = true; }

void App::create_framebuffer(uint32_t width, uint32_t height)
void App::create_scene_target()
{
qDebug() << "creating framebuffer textures for size " << width << "x" << height;

webgpu::FramebufferFormat format { .size = { width, height }, .depth_format = m_depth_texture_format, .color_formats = { m_surface_texture_format } };
m_framebuffer = std::make_unique<webgpu::Framebuffer>(m_device, format);

if (m_gui_bind_group) {
m_gui_bind_group = std::make_unique<webgpu::raii::BindGroup>(m_device,
*m_gui_bind_group_layout.get(),
std::initializer_list<WGPUBindGroupEntry> {
m_framebuffer->color_texture_view(0).create_bind_group_entry(0), m_gui_ubo->create_bind_group_entry(1) });
}

if (m_gui_ubo) {
m_gui_ubo_data.resolution = glm::vec2(m_viewport_size);
m_gui_ubo->write(m_queue, &m_gui_ubo_data);
}
WGPUTextureDescriptor desc {};
desc.label = WGPUStringView { .data = "scene target", .length = WGPU_STRLEN };
desc.dimension = WGPUTextureDimension_2D;
desc.size = { m_viewport_size.x, m_viewport_size.y, 1 };
desc.format = m_surface_texture_format;
desc.mipLevelCount = 1;
desc.sampleCount = 1;
desc.usage = WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding;
m_scene_texture = std::make_unique<webgpu::raii::Texture>(m_device, desc);
m_scene_texture_view = m_scene_texture->create_view();
}

void App::configure_surface(uint32_t width, uint32_t height)
Expand Down Expand Up @@ -513,7 +456,9 @@ void App::on_window_resize(int width, int height)
m_viewport_size = { width, height };

configure_surface(width, height);
create_framebuffer(width, height);
if (m_gui_manager)
m_gui_manager->set_viewport_size(glm::vec2(m_viewport_size));
create_scene_target();

m_webgpu_window->resize_framebuffer(m_viewport_size.x, m_viewport_size.y);
m_camera_controller->set_viewport(m_viewport_size);
Expand Down
15 changes: 4 additions & 11 deletions apps/webgpu_app/App.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,10 +48,6 @@ class App : public QObject {
App();
~App() = default;

struct GuiPipelineUBO {
glm::vec2 resolution;
};

void init_window();
void start();
void poll_events();
Expand Down Expand Up @@ -99,16 +95,13 @@ private slots:

glm::uvec2 m_viewport_size = glm::uvec2(1280u, 1024u);
bool m_initialized = false;
GuiPipelineUBO m_gui_ubo_data = { glm::vec2(1280.0, 1024.0) };

std::unique_ptr<webgpu::Framebuffer> m_framebuffer;
void create_framebuffer(uint32_t width, uint32_t height);
void configure_surface(uint32_t width, uint32_t height);
void create_scene_target();

std::unique_ptr<webgpu::raii::GenericRenderPipeline> m_gui_pipeline;
std::unique_ptr<webgpu::raii::BindGroupLayout> m_gui_bind_group_layout;
std::unique_ptr<webgpu::raii::BindGroup> m_gui_bind_group;
std::unique_ptr<webgpu::raii::RawBuffer<GuiPipelineUBO>> m_gui_ubo;
// scene texture for rendering
std::unique_ptr<webgpu::raii::Texture> m_scene_texture;
std::unique_ptr<webgpu::raii::TextureView> m_scene_texture_view;

WGPUQuerySetDescriptor m_timestamp_query_desc;
WGPUQuerySet m_timestamp_queries;
Expand Down
1 change: 1 addition & 0 deletions apps/webgpu_app/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,7 @@ set(SOURCES

ui/ImGuiPanel.h
ui/TimingPanel.h ui/TimingPanel.cpp
ui/RenderGraphPanel.h ui/RenderGraphPanel.cpp
ui/CameraPanel.h ui/CameraPanel.cpp
ui/AppPanel.h ui/AppPanel.cpp
ui/ShadingPanel.h ui/ShadingPanel.cpp
Expand Down
Loading
Loading