minitracing/src/main.rs

use std::error::Error;

use glam::{vec2, vec3};
use trace::{Sphere, Tracer, TracerData, Vertex};
use winit::{
	event::{Event, WindowEvent},
	event_loop::EventLoop,
	window::{Window, WindowAttributes},
};

mod trace;

fn make_viewport(w: u32, h: u32) -> [Vertex; 4] {
	let w = w as f32;
	let h = h as f32;
	let (w, h) = (1.0f32.max(w / h), 1.0f32.max(h / w));
	let r = 3.0f32;
	let screen_coord = [vec2(-h, -w), vec2(h, -w), vec2(-h, w), vec2(h, w)];
	let eye = vec3(-r, 0.0, 0.0);
	let world_coord = [
		vec3(0.0, -1.0, -1.0),
		vec3(0.0, 1.0, -1.0),
		vec3(0.0, -1.0, 1.0),
		vec3(0.0, 1.0, 1.0),
	];
	[0, 1, 2, 3].map(|k| Vertex {
		eye,
		world: world_coord[k],
		screen: screen_coord[k],
	})
}

fn main() {
	let event_loop = EventLoop::new().unwrap();

	#[allow(deprecated)]
	let window = &event_loop
		.create_window(WindowAttributes::new().with_title("Ray tracing reflection test"))
		.unwrap();

	let (device, queue, surface) = pollster::block_on(init_gpu(window)).unwrap();

	let mut tracer = Tracer::new(&device);
	tracer.set_params(
		&queue,
		trace::Params {
			max_reflections: 3,
			min_strength: 0.1,
			sphere_count: 2,
		},
	);

	let mut data = TracerData::new(
		&device,
		&tracer,
		&[
			Sphere {
				center: vec3(0.0, 0.0, 0.0),
				radius: 0.5,
				emit_color: vec3(0.0, 0.0, 0.5),
				reflect_color: vec3(1.0, 0.5, 0.0),
				pad1: 0.,
				pad2: 0.,
			},
			Sphere {
				center: vec3(-2.0, 0.0, 2.0),
				radius: 0.5,
				emit_color: vec3(0.5, 0.5, 0.5),
				reflect_color: vec3(0.0, 0.5, 0.0),
				pad1: 0.,
				pad2: 0.,
			},
		],
	);

	let mut surface_configured = false;
	#[allow(deprecated)]
	event_loop
		.run(move |event, control_flow| match event {
			Event::WindowEvent { ref event, window_id } if window_id == window.id() => match event {
				WindowEvent::CloseRequested => control_flow.exit(),
				WindowEvent::Resized(physical_size) => {
					surface.configure(
						&device,
						&wgpu::SurfaceConfiguration {
							usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
							format: wgpu::TextureFormat::Bgra8UnormSrgb,
							width: physical_size.width,
							height: physical_size.height,
							present_mode: wgpu::PresentMode::Fifo,
							alpha_mode: wgpu::CompositeAlphaMode::Auto,
							view_formats: vec![],
							desired_maximum_frame_latency: 2,
						},
					);
					tracer.set_view(&queue, &make_viewport(physical_size.width, physical_size.height));
					surface_configured = true;
				}
				WindowEvent::RedrawRequested => {
					window.request_redraw();
					if !surface_configured {
						return;
					}
					let output = surface.get_current_texture().unwrap();
					let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
						label: None,
						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
							view: &view,
							resolve_target: None,
							ops: wgpu::Operations {
								load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
								store: wgpu::StoreOp::Store,
							},
						})],
						depth_stencil_attachment: None,
						occlusion_query_set: None,
						timestamp_writes: None,
					});
					tracer.render(&mut render_pass, &data);
					drop(render_pass);
					queue.submit(std::iter::once(encoder.finish()));
					output.present();
				}
				_ => {}
			},
			_ => {}
		})
		.unwrap();
}

async fn init_gpu(wnd: &Window) -> Result<(wgpu::Device, wgpu::Queue, wgpu::Surface), Box<dyn Error>> {
	let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
		backends: wgpu::Backends::PRIMARY,
		..Default::default()
	});
	let surface = instance.create_surface(wnd)?;
	let adapter = instance
		.request_adapter(&wgpu::RequestAdapterOptions {
			power_preference: wgpu::PowerPreference::default(),
			compatible_surface: None,
			force_fallback_adapter: false,
		})
		.await
		.unwrap();
	let (device, queue) = adapter
		.request_device(
			&wgpu::DeviceDescriptor {
				label: None,
				required_features: wgpu::Features::empty(),
				required_limits: wgpu::Limits::default(),
				memory_hints: Default::default(),
			},
			None,
		)
		.await
		.unwrap();
	Ok((device, queue, surface))
}