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
• 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, scene::{ camera::PerspectiveCamera, mesh::Mesh, scene::Scene, }, utils::{ geometryhelper::GeometryHelper, materialhelper::MaterialHelper, }, };

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

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

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

let mesh = Mesh::new(geometry, material); let id = scene.createobject(); scene.addmesh(id, mesh);

let windowsize = window.innersize(); let camera = PerspectiveCamera::new( 60.0f32.toradians(), windowsize.width as f32 / windowsize.height as f32, 0.1, 1000.0, ); let id = scene.createobject(); scene.addcamera(id, camera); scene.setactivecamera_id(id);

scene .borrowobjectmut(id) .unwrap() .borrowpositionmut()[2] = 1.0;

scene }

fn resize(renderer: &mut WGPURenderer, scene: &mut Scene, width: u32, height: u32) { scene.borrowactivecameramut().unwrap().setaspect(width as f32 / height as f32); renderer.set_size(width as f64, height as f64); render(renderer, scene); }

fn render(renderer: &mut WGPURenderer, scene: &mut Scene) { scene.update_matrices(); renderer.render(scene); }

[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).await; renderer.setsize(windowsize.width as f64, windowsize.height as f64); renderer.setpixelratio(pixelratio);

let mut scene = create_scene(&window);

eventloop.run(move |event, _, controlflow| { *controlflow = ControlFlow::Wait; match event { Event::WindowEvent { event: WindowEvent::Resized(size), .. } => { resize(&mut renderer, &mut scene, size.width, size.height); }, Event::RedrawRequested() => { render(&mut renderer, &mut scene); }, 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.2"

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, scene::{ camera::PerspectiveCamera, mesh::Mesh, scene::Scene, }, web::wgpu_web_renderer::WGPUWebRenderer, // for web renderer::wgpu_renderer::WGPURenderer, // for others };

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.