Merge NoHit sampling

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "frontend"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[workspace]
+members = ["crates/*"]
+
+[dependencies]
+clap = { version = "4.1.8", features = ["derive", "wrap_help"] }
+gui = { path = "./crates/gui", optional = true }
+implementations = { path = "./crates/implementations" }
+indicatif = "0.17.3"
+loader = { path = "./crates/loader" }
+output = { path = "./crates/output" }
+rand = { version = "0.8.3", features = [ "small_rng" ] }
+rand_seeder = "0.2.2"
+rayon = "1.5.1"
+region = { path = "./crates/region" }
+vulkano = { version = "0.28.0", optional = true }
+vulkano-shaders = { version = "0.28.0", optional = true }
+vulkano-win = { version = "0.28.0", optional = true }
+winit = { version = "0.26.1", optional = true }
+
+[features]
+f64 = ["implementations/f64"]
+gui = ["dep:vulkano", "dep:vulkano-win", "dep:vulkano-shaders", "dep:winit", "dep:gui"]

crates/gui/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "gui"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+vulkano = { version = "0.28.0" }
+vulkano-shaders = { version = "0.28.0" }
+vulkano-win = { version = "0.28.0" }
+winit = { version = "0.26.1" }
+implementations = { path = "../implementations" }
+indicatif = "0.17.3"

frontend/src/gui.rs → crates/gui/src/gui.rs

@@ -1,4 +1,6 @@
-use crate::rendering::*;
+use crate::rendering::CpuRendering;
+use crate::rendering::RenderInfo;
+use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use vulkano::{
 	command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer},
@@ -40,10 +42,11 @@ pub struct Gui {
 	render_info: RenderInfo,
 	combined_buffer: Arc<StorageImage>,
 	presentation_finished: Option<Box<dyn GpuFuture + 'static>>,
+	exit: Arc<AtomicBool>,
 }
 
 impl Gui {
-	pub fn new(instance: &Arc<Instance>, width: u32, height: u32) -> Self {
+	pub fn new(instance: &Arc<Instance>, width: u32, height: u32, exit: Arc<AtomicBool>) -> Self {
 		let event_loop: EventLoop<RenderEvent> = EventLoop::with_user_event();
 		let surface = WindowBuilder::new()
 			.build_vk_surface(&event_loop, instance.clone())
@@ -139,9 +142,7 @@ impl Gui {
 		let cpu_rendering = CpuRendering::new(&physical_device, device.clone(), width, height);
 
 		mod cs {
-			vulkano_shaders::shader! {
-			ty: "compute",
-			src:
+			vulkano_shaders::shader! {ty: "compute",src:
 "#version 460
 
 layout(local_size_x = 32, local_size_y = 32) in;
@@ -151,8 +152,8 @@ layout(set = 0, binding = 0, rgba32f) uniform readonly image2D cpu_input;
 layout(set = 0, binding = 1, rgba8) uniform writeonly image2D image_output;
 
 void main() {
-        vec4 data = sqrt(imageLoad(cpu_input, ivec2(gl_GlobalInvocationID.xy)));
-        imageStore(image_output, ivec2(gl_GlobalInvocationID.xy), data);
+	vec4 data = sqrt(imageLoad(cpu_input, ivec2(gl_GlobalInvocationID.xy)));
+	imageStore(image_output, ivec2(gl_GlobalInvocationID.xy), data);
 }"}
 		}
 
@@ -201,6 +202,7 @@ void main() {
 			presentation_command_buffers,
 			combined_buffer,
 			presentation_finished: None,
+			exit,
 		}
 	}
 
@@ -213,14 +215,14 @@ void main() {
 				Event::DeviceEvent {
 					event: winit::event::DeviceEvent::Key(key),
 					..
-				} => match key.virtual_keycode {
-					Some(code) => {
+				} => {
+					if let Some(code) = key.virtual_keycode {
 						if code == winit::event::VirtualKeyCode::Escape {
+							self.exit.store(true, std::sync::atomic::Ordering::Relaxed);
 							*control_flow = ControlFlow::Exit;
 						}
 					}
-					None => {}
-				},
+				}
 				Event::WindowEvent {
 					event: WindowEvent::CloseRequested,
 					..
@@ -246,9 +248,8 @@ void main() {
 	}
 
 	fn update(&mut self) {
-		match self.presentation_finished.as_mut() {
-			Some(future) => future.cleanup_finished(),
-			None => {}
+		if let Some(future) = self.presentation_finished.as_mut() {
+			future.cleanup_finished()
 		}
 		self.presentation_finished = Some(sync::now(self.device.clone()).boxed());
 
@@ -260,7 +261,7 @@ void main() {
 					return;
 				}
 				Err(e) => {
-					panic!("Failed to acquire next image: {:?}", e)
+					panic!("Failed to acquire next image: {e:?}")
 				}
 			};
 
@@ -328,7 +329,7 @@ void main() {
 				self.presentation_finished = Some(sync::now(self.device.clone()).boxed());
 			}
 			Err(e) => {
-				println!("Failed to flush future: {:?}", e);
+				println!("Failed to flush future: {e:?}");
 				self.presentation_finished = Some(sync::now(self.device.clone()).boxed());
 			}
 		}
@@ -339,7 +340,7 @@ void main() {
 			match self.swapchain.recreate().dimensions(dimensions).build() {
 				Ok(r) => r,
 				Err(SwapchainCreationError::UnsupportedDimensions) => return,
-				Err(e) => panic!("Failed to recreate swapchain: {:?}", e),
+				Err(e) => panic!("Failed to recreate swapchain: {e:?}"),
 			};
 		let extent: [u32; 2] = self.surface.window().inner_size().into();
 

crates/gui/src/lib.rs

@@ -0,0 +1,184 @@
+mod gui;
+mod rendering;
+
+use implementations::SamplerProgress;
+use indicatif::ProgressBar;
+use indicatif::ProgressStyle;
+
+use {
+	std::sync::{
+		atomic::{AtomicBool, AtomicU64, Ordering},
+		Arc,
+	},
+	vulkano::{
+		buffer::CpuAccessibleBuffer,
+		command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer},
+		device::{Device, Queue},
+		image::StorageImage,
+		sync::{self, GpuFuture},
+	},
+	winit::event_loop::EventLoopProxy,
+};
+
+pub use crate::gui::{Gui, RenderEvent};
+pub use crate::rendering::Future;
+
+pub struct Data {
+	pub queue: Arc<Queue>,
+	pub device: Arc<Device>,
+	pub to_sc: rendering::Future,
+	pub from_sc: rendering::Future,
+	pub command_buffers: [Arc<PrimaryAutoCommandBuffer>; 2],
+	pub buffer: Arc<CpuAccessibleBuffer<[f32]>>,
+	pub sc_index: Arc<AtomicBool>,
+	pub samples: Arc<AtomicU64>,
+	pub total_samples: u64,
+	pub rays_shot: Arc<AtomicU64>,
+	pub event_proxy: EventLoopProxy<RenderEvent>,
+	pub exit: Arc<AtomicBool>,
+	pub bar: ProgressBar,
+}
+
+impl Data {
+	pub fn new(
+		queue: Arc<Queue>,
+		device: Arc<Device>,
+		to_sc: rendering::Future,
+		from_sc: rendering::Future,
+		command_buffers: [Arc<PrimaryAutoCommandBuffer>; 2],
+		buffer: Arc<CpuAccessibleBuffer<[f32]>>,
+		sc_index: Arc<AtomicBool>,
+		samples: Arc<AtomicU64>,
+		total_samples: u64,
+		rays_shot: Arc<AtomicU64>,
+		exit: Arc<AtomicBool>,
+		event_proxy: EventLoopProxy<RenderEvent>,
+	) -> Self {
+		Data {
+			queue,
+			device,
+			to_sc,
+			from_sc,
+			command_buffers,
+			buffer,
+			sc_index,
+			samples,
+			total_samples,
+			rays_shot,
+			event_proxy,
+			exit,
+			bar: ProgressBar::new(total_samples).with_style(
+				ProgressStyle::default_bar()
+					.template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")
+					.unwrap(),
+			),
+		}
+	}
+}
+
+pub fn create_command_buffers(
+	device: Arc<Device>,
+	queue: Arc<Queue>,
+	buffer: Arc<CpuAccessibleBuffer<[f32]>>,
+	sc: [Arc<StorageImage>; 2],
+) -> [Arc<PrimaryAutoCommandBuffer>; 2] {
+	let mut command_buffer_0 = None;
+	let mut command_buffer_1 = None;
+	for (i, sc_image) in sc.iter().enumerate() {
+		let mut builder = AutoCommandBufferBuilder::primary(
+			device.clone(),
+			queue.family(),
+			CommandBufferUsage::MultipleSubmit,
+		)
+		.unwrap();
+
+		builder
+			.copy_buffer_to_image(buffer.clone(), sc_image.clone())
+			.unwrap();
+		if i == 0 {
+			command_buffer_0 = Some(builder.build().unwrap());
+		} else {
+			command_buffer_1 = Some(builder.build().unwrap());
+		}
+	}
+
+	[
+		Arc::new(command_buffer_0.unwrap()),
+		Arc::new(command_buffer_1.unwrap()),
+	]
+}
+
+pub fn sample_update(data: &mut Data, previous: &SamplerProgress, i: u64) -> bool {
+	if data.exit.load(Ordering::Relaxed) {
+		return true;
+	}
+	// update infomation about the rays shot and samples completed in the current render
+	data.samples.fetch_add(1, Ordering::Relaxed);
+	data.rays_shot
+		.fetch_add(previous.rays_shot, Ordering::Relaxed);
+
+	// wait on from_sc future if is_some()
+	match &*data.from_sc.lock().unwrap() {
+		Some(future) => {
+			future.wait(None).unwrap();
+		}
+		None => {}
+	}
+	match &*data.to_sc.lock().unwrap() {
+		Some(future) => {
+			future.wait(None).unwrap();
+		}
+		None => {}
+	}
+
+	{
+		// get access to CpuAccessibleBuffer
+		let mut buf = data.buffer.write().unwrap();
+		buf.chunks_mut(4)
+			.zip(previous.current_image.chunks(3))
+			.for_each(|(pres, acc)| {
+				pres[0] += (acc[0] as f32 - pres[0]) / i as f32;
+				pres[1] += (acc[1] as f32 - pres[1]) / i as f32;
+				pres[2] += (acc[2] as f32 - pres[2]) / i as f32;
+				pres[3] = 1.0;
+			});
+	}
+
+	// copy to cpu swapchain
+	let command_buffer =
+		data.command_buffers[data.sc_index.load(Ordering::Relaxed) as usize].clone();
+
+	// copy to swapchain and store op in to_sc future
+	{
+		let to_sc = &mut *data.to_sc.lock().unwrap();
+		*to_sc = Some(
+			match to_sc.take() {
+				Some(future) => future
+					.then_execute(data.queue.clone(), command_buffer)
+					.unwrap()
+					.boxed_send_sync(),
+				None => sync::now(data.device.clone())
+					.then_execute(data.queue.clone(), command_buffer)
+					.unwrap()
+					.boxed_send_sync(),
+			}
+			.then_signal_fence_and_flush()
+			.unwrap(), // change to match
+		);
+	}
+
+	// modify sc_index to !sc_index
+	data.sc_index
+		.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |x| Some(!x))
+		.unwrap();
+
+	data.bar.set_position(data.samples.load(Ordering::Relaxed));
+	if data.samples.load(Ordering::Relaxed) == data.total_samples {
+		data.bar.abandon()
+	}
+
+	// signal sample is ready to be presented
+	data.event_proxy
+		.send_event(RenderEvent::SampleCompleted)
+		.is_err()
+}

implementations/Cargo.toml → crates/implementations/Cargo.toml

@@ -7,11 +7,21 @@ edition = "2021"
 
 [dependencies]
 image = "0.24.3"
-proc = {path = "./proc"}
+proc = { path = "./proc" }
 rand = { version = "0.8.3", features = [ "small_rng" ] }
 rayon = "1.5.1"
-rt_core = {path = "../rt_core"}
+rt_core = { path = "../rt_core" }
+bumpalo = {version="3.12.0", features=["collections"]}
+num_cpus = "1.15"
+region = { path = "../region"}
+statrs = "0.16.0"
+clap = { version = "4.1.8", features = [ "derive" ] }
+
+
 
 [dev-dependencies]
 chrono = "0.4.19"
-statrs = "0.16.0"
+statrs = "0.16.0"
+
+[features]
+f64 = ["rt_core/f64"]

implementations/proc/src/lib.rs → crates/implementations/proc/src/lib.rs

@@ -122,7 +122,7 @@ pub fn derive_primitive(tokens: TokenStream) -> TokenStream {
 
 	let func_names_primitive = [
 		(
-			quote!(get_int(&self, __one: &Ray) -> Option<SurfaceIntersection #ty_generics>),
+			quote!(get_int(&self, __one: &Ray) -> Option<SurfaceIntersection<Self::Material>>),
 			quote!(get_int(__one)),
 		),
 		(
@@ -177,7 +177,10 @@ pub fn derive_primitive(tokens: TokenStream) -> TokenStream {
 	});
 
 	quote! {
-		impl #impl_generics Primitive #ty_generics for #enum_name #ty_generics #where_clause {#( #functions_primitive )*}
+		impl #impl_generics Primitive for #enum_name #ty_generics #where_clause {
+			type Material = M;
+			#( #functions_primitive )*
+		}
 		impl #impl_generics AABound for #enum_name #ty_generics #where_clause { #( #functions_aabound )*}
 	}
 	.into()

implementations/src/acceleration/aabb.rs → crates/implementations/src/acceleration/aabb.rs

@@ -1,5 +1,5 @@
 use crate::utility::gamma;
-use rt_core::{Float, Ray, Vec3};
+use rt_core::*;
 
 pub trait AABound {
 	fn get_aabb(&self) -> AABB;