wgpu-rust-renderer

wgpu-rust-renderer is a tiny WebGPU Renderer written in Rust.

Demo

Online WebAssembly Demo

Rust code is compiled to WebAssembly with wasm-bindgen and it runs even in web browsers.

Screenshots

Desktop application.

Web application.

Features

• Tiny WebGPU Renderling library
• Easy to use
• Memory safe with Rust
• glTF support
• Good flexibility and extensibility of materials with node-based material system
• Web application compatible by compiling to WebAssembly

Documents

T.B.D.

Sample Code

```rust use winit::{ event::{Event, WindowEvent}, eventloop::{ControlFlow, EventLoop}, window::Window, }; use wgpurustrenderer::{ math::color::Color, renderer::wgpurenderer::{ WGPURenderer, WGPURendererOptions, }, resource::resource::{ ResourceId, ResourcePools, }, scene::{ camera::PerspectiveCamera, mesh::Mesh, node::Node, scene::Scene, }, utils::{ geometryhelper::GeometryHelper, materialhelper::MaterialHelper, }, };

fn create_scene( window: &Window, pools: &mut ResourcePools, ) -> (ResourceId, ResourceId) { let mut scene = Scene::new();

let geometry = GeometryHelper::create_triangle( pools, 1.0, 1.0, );

let material = MaterialHelper::createbasicmaterial( pools, Color::set(&mut Color::create(), 1.0, 0.0, 0.0), );

let mesh = pools.borrowmut::() .add(Mesh::new(geometry, material)); let node = pools.borrowmut::() .add(Node::new()); scene.add_node(&node); scene.assign(&node, &mesh);

let windowsize = window.innersize(); let camera = pools.borrowmut::().add( PerspectiveCamera::new( 60.0f32.toradians(), windowsize.width as f32 / window_size.height as f32, 0.1, 1000.0, ), );

let mut node = Node::new(); node.borrowpositionmut()[2] = 1.0;

let node = pools.borrowmut::().add(node); scene.addnode(&node); scene.assign(&node, &camera);

(pools.borrow_mut::().add(scene), camera) }

fn resize( renderer: &mut WGPURenderer, pools: &mut ResourcePools, camera: &ResourceId, width: u32, height: u32, ) { pools .borrowmut::() .borrowmut(camera) .unwrap() .setaspect(width as f32 / height as f32); renderer.setsize(width as f64, height as f64); }

fn update( pools: &mut ResourcePools, scene: &ResourceId, ) { pools.borrow::() .borrow(scene) .unwrap() .update_matrices(pools); }

fn render( renderer: &mut WGPURenderer, pools: &ResourcePools, scene: &ResourceId, camera: &ResourceId, ) { renderer.render(pools, scene, camera); }

[tokio::main]

async fn main() { let eventloop = EventLoop::new(); let window = Window::new(&eventloop).unwrap();

let windowsize = window.innersize(); let pixelratio = window.scalefactor();

let mut renderer = WGPURenderer::new( &window, WGPURendererOptions::default(), ).await; renderer.setsize(windowsize.width as f64, windowsize.height as f64); renderer.setpixelratio(pixelratio);

let mut pools = ResourcePools::new(); let (scene, camera) = create_scene(&window, &mut pools);

eventloop.run(move |event, _, controlflow| { *controlflow = ControlFlow::Wait; match event { Event::WindowEvent { event: WindowEvent::Resized(size), .. } => { resize(&mut renderer, &mut pools, &camera, size.width, size.height); update(&mut pools, &scene); render(&mut renderer, &mut pools, &scene, &camera); }, Event::RedrawRequested() => { update(&mut pools, &scene); render(&mut renderer, &mut pools, &scene, &camera); }, Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => { *control_flow = ControlFlow::Exit; }, _ => {} } }); } ```

How to import

The library is released at crates.io. Add the following line into Cargo.toml of your Rust project.

[dependencies] wgpu_rust_renderer = "0.0.3"

And add the following lines in your Rust code to import the library.

Rust use wgpu_rust_renderer::{ geometry::{ attribute::Attribute, geometry::Geometry, index::Index, }, material::material::Material, resource::resource::{ ResourceId, ResourcePools, }, scene::{ camera::PerspectiveCamera, mesh::Mesh, node::Node, scene::Scene, }, web::wgpu_web_renderer::WGPUWebRenderer, // for web renderer::wgpu_renderer::{ WGPURenderer, // for others WGPURendererOptions, }, };

How to build the library locally

sh $ git clone https://github.com/takahirox/wgpu-rust-renderer.git $ cd wgpu-rust-renderer $ cargo build

How to run desktop examples locally

sh $ cd wgpu-rust-renderer $ cargo run --example example_name

How to run web examles locally

Prerequirements - Install wasm-bindgen client - Install Rust wasm32-unknown-unknown target with $ rustup target add wasm32-unknown-unknown - Install http-server with $ npm install -g http-server, or other local servers

```sh $ cd wgpu-rust-renderer/web $ bash build_examples.sh $ http-server . -p 8080 -c-1

Access http://localhost:8080/examples/index.html on your web browser

```

How to run tests

T.B.D.