## vtkRenderingWebGPU - WebGPU backend for rendering
## vtkRenderingWebGPU - WebGPU Backend for Rendering
### Description
This module contains the WebGPU native backend for `RenderingCore`. At the moment, only polygonal geometry can be rendered in different representations with point/cell scalar mapped colors.
#### Available features
Here is a list of currently implemented features:
1. Polygonal geometry rendering with point, line and triangle primitives.
2. Point scalar mapped coloring of surfaces.
3. Cell scalar mapped coloring.
4. Draw actors with the actor representation = `VTK_POINTS`, `VTK_WIREFRAME`, `VTK_SURFACE` and `VTK_SURFACE` with edge visibility.
5. Lighting based on VTK headlights and point/cell normals.
6. Point size adjustments.
7. Line width adjustments for wireframe and surface with edges.
8.`vtkWebAssemblyWebGPURenderWindow` is a reference implementation of `vtkWebGPURenderWindow` that works on WebAssembly and desktop.
9.`vtkXWebGPURenderWindow` is an implementation of `vtkWebGPURenderWindow` that uses X11 for Linux desktop rendering.
10. Depth testing.
###### Compute shader API
The compute shader API allows offloading work from the CPU onto the GPU using WebGPU compute shaders.
User-level information about the usage of the API can be found [here](./webgpu-compute-api-user.md).
Developper-level information about the API can be found [here](./webgpu-compute-api-dev.md).
#### Future work
Since WebGPU is already an abstraction over graphics APIs, this module doesn't create another level of abstraction. It uses WebGPU's C++ flavor
for it's object-oriented API and RAII. There are helper classes in the `vtkWebGPUInternals...` files for convenience and to make the bind group
initialization code look clean.
A lot of work remains to be done. Selections, volume mappers, textures, dual-depth peeling, fancy lights, platform native render windows are few that come to mind.
#### References
Here are some very interesting references to learn WebGPU from examples if you prefer code over spec.
1. https://toji.github.io/webgpu-gltf-case-study/
A case-study that slowly builds up an efficient gltf renderer in WebGPU using javascript. The author describes downfalls in
certain methods and proposes alternative ways when applicable.
This module uses Dawn-C++ WebGPU implementation when VTK is built outside emscripten. First grab [Dawn](https://dawn.googlesource.com/dawn/) and follow their
build instructions using `gn`, not CMake.
To build VTK with Dawn, you need to build Dawn at tag [chromium/6594](https://dawn.googlesource.com/dawn.git/+show/chromium/6594).
Subsequent commits have changed the public API of Dawn to a great extent, making it incompatible with VTK.
Dawn uses the Chromium build system and dependency management so you need to install [depot_tools](http://commondatastorage.googleapis.com/chrome-infra-docs/flat/depot_tools/docs/html/depot_tools_tutorial.html#_setting_up) and add it to the PATH.
This module contains the WebGPU native backend for `RenderingCore`. Currently, it supports rendering polygonal geometry in different representations with point/cell scalar-mapped colors.
When both the `RenderingOpenGL2` and `RenderingWebGPU` libraries are linked, the user must set the
`VTK_GRAPHICS_BACKEND` environment variable to either `WEBGPU` or `OPENGL` in order to activate
the intended object factories. In the future, we plan to enhance the object factory mechanism to accept command
line arguments.
---
### Building VTK with Dawn (Highly Experimental)
#### Prerequisites
- Git
- tools for building VTK
This module uses Dawn's C++ WebGPU implementation on desktop and the `emdawnwebgpu` subcomponent for wasm. You can either build Dawn from scratch or download pre-built releases for your machine from [kitware:utils/ci-utilities/dawn-v7037-20250226.0](https://gitlab.kitware.com/utils/ci-utilities/-/releases/dawn%2Fv7037-20250226.0)
#### Cloning and Building Dawn
Dawn should be built at tag [chromium/7037](https://dawn.googlesource.com/dawn.git/+show/chromium/7037).
```sh
# Clone the repo as "dawn"
# Clone the repo and checkout the required version
git clone https://dawn.googlesource.com/dawn dawn &&cd dawn
These are not regression tested with image comparisons.
---
### Running Tests
#### WebGPU Tests
```sh
$ ./bin/vtkRenderingWebGPUCxxTests
./bin/vtkRenderingWebGPUCxxTests
```
Available tests:
0. TestCellScalarMappedColors
1. TestConesBenchmark
2. TestLineRendering
3. TestPointScalarMappedColors
4. TestSurfacePlusEdges
5. TestTheQuad
6. TestTheQuadPointRepresentation
7. TestTheQuadWireframeRepresentation
8. TestTheTriangle
9. TestTheTrianglePointRepresentation
10. TestTheTriangleWireframeRepresentation
11. TestVertexRendering
12. TestWireframe
```
0. TestActorFaceCullingProperty
1. TestAxesActor
2. TestCellScalarMappedColors
3. TestCompositePolyDataMapper
..
..
```
#### Rendering Core Tests
To run the `RenderingCore` tests with `VTK::RenderingWebGPU`, edit `vtk.module` to link unit tests with `TEST_DEPENDS`:
1. Uncomment the module name under `TEST_DEPENDS`.
2. Rebuild and run the tests (only a few pass currently).
3. Set the `VTK_GRAPHICS_BACKEND` environment variable to `WEBGPU`
##### Run the Rendering Core tests
The RenderingCore vtk.module can be edited to link the unit tests with `VTK::RenderingWebGPU` module. After uncommenting the module name under `TEST_DEPENDS`, rebuild and run the tests. Very few of these pass.
```sh
$ export VTK_GRAPHICS_BACKEND=WEBGPU
$ ./bin/vtkRenderingCoreCxxTests
export VTK_GRAPHICS_BACKEND=WEBGPU
./bin/vtkRenderingCoreCxxTests
```
---
### Features
The following features are currently implemented:
-**vtkPolyData Rendering**: Supports point, line, and triangle primitives.
-**Glyph Rendering**: Supports point, line, and triangle primitives.
-**Composite vtkPolyData Rendering**: Supports point, line, and triangle primitives.
-**Scalar Mapped Coloring**:
- Point scalar mapped coloring of surfaces.
- Cell scalar mapped coloring.
-**Actor Representations**:
-`VTK_POINTS`
-`VTK_WIREFRAME`
-`VTK_SURFACE`
-`VTK_SURFACE` with edge visibility
-**Lighting**:
- Based on VTK headlights.
- Supports point/cell normals.
-**Rendering Adjustments**:
- Point size adjustments.
- Line width adjustments for wireframe and surface with edges.
-**Rendering Backends**:
-`vtkWebAssemblyWebGPURenderWindow`: A reference implementation of `vtkWebGPURenderWindow` for WebAssembly and desktop.
-`vtkXWebGPURenderWindow`: Implementation using X11 for Linux desktop rendering.
-**Depth Testing**: Enables correct rendering of 3D objects.
- **Selections**: Hardware selector can pick cells, composite datasets and actors.
---
### Compute Shader API
The compute shader API allows offloading work from the CPU to the GPU using WebGPU compute shaders.
-**User-level information**: [Compute API User Guide](./doc/webgpu-compute-api-user.md)
-**Developer-level information**: [Compute API Developer Guide](./doc/webgpu-compute-api-dev.md)
---
### Future Work
Since WebGPU is already an abstraction over graphics APIs, this module avoids creating another level of abstraction. It leverages WebGPU's C++ flavor for its object-oriented API and RAII. Helper classes in the `vtkWebGPUInternals...` files ensure cleaner bind group initialization code.
Planned improvements include:
- Volume mappers
- Textures
- Dual-depth peeling
- Advanced lighting
- Platform-native render windows for Windows, macOS, Android, iOS and wayland.
---
### References
Here are some valuable resources for learning WebGPU:
