WGPU (WebGPU/Vulkan/Metal etc) renderer

Cargo.toml

@@ -3,5 +3,6 @@ resolver = "2"
 members = [
     "inox2d",
     "inox2d-opengl",
+    "inox2d-wgpu",
     "examples/*",
 ]

examples/render-opengl/src/main.rs

@@ -135,9 +135,7 @@ impl App for Inox2dOpenglExampleApp {
 		// Just that physics simulation will run for the provided time, which may be big and causes a startup delay.
 		puppet.end_frame(scene_ctrl.dt());
 
-		renderer.on_begin_draw(puppet);
-		renderer.draw(puppet);
-		renderer.on_end_draw(puppet);
+		renderer.draw(puppet).expect("successful draw");
 	}
 
 	fn handle_window_event(&mut self, event: WindowEvent, elwt: &EventLoopWindowTarget<()>) {

examples/render-webgl/src/main.rs

@@ -137,9 +137,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
 				// Just that physics simulation will run for the provided time, which may be big and causes a startup delay.
 				puppet.end_frame(scene_ctrl.borrow().dt());
 
-				renderer.borrow().on_begin_draw(&puppet);
-				renderer.borrow().draw(&puppet);
-				renderer.borrow().on_end_draw(&puppet);
+				renderer.borrow_mut().draw(&puppet);
 			}
 
 			request_animation_frame(anim_loop_f.borrow().as_ref().unwrap());

examples/render-wgpu/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "render-wgpu"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+common = { path = "../common" }
+inox2d = { path = "../../inox2d" }
+inox2d-wgpu = { path = "../../inox2d-wgpu"}
+winit = "0.29"
+env_logger = "0.11.9"
+log = "0.4.29"
+clap = { version = "4.1.8", features = ["derive"] }
+pollster = "0.4.0"

examples/render-wgpu/src/main.rs

@@ -0,0 +1,94 @@
+use clap::Parser;
+use common::scene::ExampleSceneController;
+use env_logger;
+use inox2d::formats::inp::parse_inp;
+use inox2d::math::camera::Camera;
+use inox2d::render::InoxRendererExt;
+use inox2d_wgpu::WgpuRenderer;
+use log::*;
+use pollster::block_on;
+use winit::event::{Event, WindowEvent};
+use winit::event_loop::{ControlFlow, EventLoop};
+use winit::window::WindowBuilder;
+
+use std::error::Error;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+	#[arg(help = "Path to the .inp or .inx file.")]
+	inp_path: PathBuf,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+	let cli = Cli::parse();
+
+	env_logger::init();
+
+	let event_loop = EventLoop::new()?;
+
+	info!("Loading {:?}", cli.inp_path);
+
+	let data = fs::read(cli.inp_path)?;
+	let mut model = parse_inp(data.as_slice())?;
+
+	info!(
+		"Successfully parsed puppet: {}",
+		(model.puppet.meta.name.as_deref()).unwrap_or("<no puppet name specified in file>")
+	);
+
+	model.puppet.init_transforms();
+	model.puppet.init_rendering();
+	model.puppet.init_params();
+	model.puppet.init_physics();
+
+	model.puppet.begin_frame();
+	model.puppet.end_frame(0.01);
+
+	let window = Arc::new(WindowBuilder::new().build(&event_loop).expect("valid window"));
+	let mut renderer = block_on(WgpuRenderer::new(window.clone(), &model)).expect("valid renderer");
+	let mut scene_controller = ExampleSceneController::new(&Camera::default(), 0.5);
+	let camera = Camera::default();
+
+	event_loop.set_control_flow(ControlFlow::Poll);
+	event_loop.run(|event, event_loop| {
+		match event {
+			Event::WindowEvent {
+				event: WindowEvent::Resized(new_size),
+				..
+			} => {
+				if let Err(err) = renderer.resize(new_size.width, new_size.height) {
+					error!("Resize failed: {}", err);
+				}
+			}
+			Event::WindowEvent {
+				event: WindowEvent::CloseRequested,
+				..
+			} => {
+				event_loop.exit();
+			}
+			Event::WindowEvent {
+				event: WindowEvent::RedrawRequested,
+				..
+			} => {
+				if let Err(err) = renderer.draw(&model.puppet) {
+					error!("Draw failed: {}", err);
+				}
+			}
+			Event::WindowEvent { event, .. } => {
+				scene_controller.interact(&event, &camera);
+			}
+			Event::AboutToWait => {
+				window.request_redraw();
+
+				//TODO: Swapchain? Swapchain.
+			}
+			_ => {}
+		}
+	})?;
+
+	Ok(())
+}