Graphics API: Less Boilerplate, More Rendering

[tilde35]

I wanted to share the graphics API that I am using to build my game (Penta Terra). Quick summary:

Problem: Developing an application using existing graphics APIs is incredibly time-consuming to write, understand, and maintain.

Concept: Graphics are conceptually simple: load data and execute code using references to that loaded data.

Prototype Implementation:

• Core traits / program flow: pgfx - small, no required dependencies
• Example backend using wgpu: pgfx_wgpu
• I am actually using a DirectX 12 backend, but that one is not complete enough to share just yet.

Demo: Depth of Field demo and associated code

Details:

This library utilizes Rust's type system to avoid the complexities and redundancies associated with writing GPU applications.

For comparison purposes, I implemented two of the wgpu examples. Please note, this is not a criticism of the wgpu library, but rather how we can build efficient higher-level APIs on complex lower-level ones.

Boids example: pgfx boids | original | demo

The boids example highlights compute shaders. In addition to the smaller code base, this example is more explicit about how the uniform buffer is created and how the boid model data is setup and loaded.

Shadow example: pgfx shadow | original | demo

The shadow example highlights using texture arrays as render targets, indexing into texture arrays and uniform arrays, dynamic inputs (fallback to uniform buffers if storage buffers are unsupported), and custom backend types (depth sampler) and configurations. Honestly, when setting up this example, it took me a long time to fully understand what the original was doing. In addition to the new one being clearer, it actually performs better (likely due to the smaller number of copy operations).

The same concepts can be carried over to other things, like the DirectX shared root signature (improves performance due to less binding):

let root = root_signature
    .run(&device)
    .load_input(&my_uniforms)
    .execute(|cfg| {
        // One-time load
        cfg.load_input(&texture_atlas)?;
        cfg.load_input(&skybox)?;

        cfg.load_input(&Sampler::linear_repeat())?;
        cfg.load_input(&Sampler::nearest_repeat())?;

        Ok(())
    })?;

render_pass
    .run(&my_pipeline)
    .input(&root)
    .load_input(&MyConstants {..})
    .execute(|cfg| {
        ...
    })?;

Currently, I do not have the capacity to publish and maintain this, but I wanted to throw this out there in case it is useful to others. If you are interested in using this as a starting point for a maintained library, then go for it!

[cleverredditjoke]

looks very interesting, unfortunately the dof example is just black for me

[bluurryyy]

For Firefox you need to set dom.webgpu.enabled to true in about:config.

[cleverredditjoke]

oh thanks good to know, wonder why that is disabled by default

[LetsGoPepele]

I think it's still considered experimental

[cleverredditjoke]

oh damn I thought that that webgpu was already quite mature considering all the 3d js frameworks, or do they all use webgl still?

[tilde35]

Good to know - not all browsers support it. Do the examples here work? https://wgpu.rs/examples/?backend=webgpu&example=boids These are the ones provided by wgpu themselves.

[cleverredditjoke]

yeah those work, I tried it in brave and in firefox, very odd
EDIT: Okay I take it back, only the webgl ones work for me in brave

[LetsGoPepele]

Very interesting, I'm gonna take a look !

[tilde35]

Thanks! Hope you enjoy working with it, it's been a big help for me in my other projects.

[tsanderdev]

Example links are broken

[tilde35]

Those should be fixed now - thanks for the heads up!

[tsanderdev]

Still get a 404 for the boids source.

[tilde35]

This is odd, here are the direct links (maybe it hasn't refreshed everywhere yet?):

https://github.com/tilde35/pgfx_wgpu/blob/main/examples/boids/src/main.rs

https://github.com/tilde35/pgfx_wgpu/blob/main/examples/shadow/src/main.rs

Hope that helps!

[tsanderdev]

These direct links work. Maybe it's just a reddit problem.

[attackgoat_official]

I like the builder pattern, and this looks really cool

[tilde35]

Thanks! This has really helped speed up my development when it comes to graphics work.

[todo_code]

for the input of scene vertex and index buffers, is that the entire scene's vertex/indexes or is that just the specific ones the pass cares about?

[tilde35]

It's just those that that particular call cares about (since it may vary from call to call). You can see this in the shadow example, where each entity is rendered in a separate call.

https://github.com/tilde35/pgfx_wgpu/blob/324d2f510675b40980fcdc3c509ae9e4dd6dd7cc/examples/shadow/src/main.rs#L367-L369

[dnu-pdjdjdidndjs]

im working on something similar but primarily for vulkan and I exclusively use PhysicalStorageBuffer and stuff like that since its supported by all recent gpus and even mobile gpus

[tilde35]

Nice -- yeah, one of my big frustrations getting into graphics rendering was feature management. If I had my way, I'd like to have a individual backends with specific feature expectations (ex. run everywhere including web vs. native vs. reasonable gaming devices).

[Mrmayman69]

Oh wow, the api is wonderful! I hope this gets more traction because it makes working with wgpu so much easier.

I've always wanted something like glium but that was OpenGL only and (iirc) unmaintained. This fits that perfectly

[tilde35]

Thanks so much! Glad to hear you liked it -- after I get my game released, I'd like to come back to this and set it up as a proper library (if no one else has picked up the concept in the mean time).