Why learning wgpu in rust is so convoluted and difficult?

[petrasvestartas]

I am spending a good 2 months on this. It is hard and making visualization ready apps becomes very cumbersome.

Can anyone create new tutorials?

[sotrh]

What are you struggling with specifically? What kind of visualizations are you trying to do? WGPU can feel overwhelming coming from OpenGL as WGPU doesn't make decisions for you. It expects you to tell it everything you want it to do. So to reiterate, where have you gotten stuck?

[petrasvestartas]

I managed to write a viewer based on your examples: https://github.com/petrasvestartas/wgpu_viewer.

Now, both the web and local viewers are working.

The problem is that the project has become so large — the main lib.rs file is over 2000 lines — that I can no longer manage it easily. It’s essentially a patchwork of examples for both web and native viewers. I no longer know how to properly split the code into manageable pieces. I’ve given up and feel like starting from scratch.

Learning how to develop for a web-based viewer has been extremely difficult. I’ve tried to follow various online tutorials, but they often don’t work as expected, and you always have to piece them together from other resources. In the end, I used examples as a starting point, but since they’re fully complete, it’s hard to understand what each part actually does.

Honestly, I feel completely lost...

[sotrh]

2000k lines sounds about right. WebGPU has a lot of boilerplate. One thing that might cut it down a bit is reducing some of your redundant code. In particular I noticed you have a model type with custom vertex type for every shape. Most of the vertex types seem to be basically the same with position and color fields which you could simplify into one vertex type:

#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct ColoredVertex {
    position: [f32; 3],
    color: [f32; 3],
}

Also you only need one model type. If you want the model type to support different vertex types you can use generics:

// Require anything implementing Vertex to implement Pod and Zeroable
pub trait Vertex: bytemuck::Pod + bytemuck::Zeroable {
    fn vertex_desc() -> wgpu::BufferLayout<'static>;
}

pub struct Model<T: Vertex> {
    vertex_buffer: wgpu::Buffer,
    index_buffer: wgpu::Buffer,
    num_elements: u32,
    // In order to use generics, something has to use T. Since the data is
    // stored on the GPU we use PhantomData to do that.
    _marker: PhantomData<T>,
}

impl<T: Vertex> Model<T> {
    // ...
}

Using this we can have Model<ModelVertex>, Model<ColoredVertex> and any other type of model without needing to create a model struct for each shape. If you want a function to handle any model you can do something like this:

fn render_model(&mut self, model: &Model<impl Vertex>) {
    // ...
}

That way you don't have to duplicate any code. It should cut down your project a bit.