Change Scene trait to account for material data

ray-tracing-egui/src/main.rs

@@ -236,9 +236,9 @@ fn main() {
                     });
 
                     settings_changed |= egui::ComboBox::from_label("Renderer")
-                        .selected_text(RENDERER[settings.renderer_id].0)
+                        .selected_text(RENDERER[settings.renderer_id])
                         .show_index(ui, &mut settings.renderer_id, RENDERER.len(), |i| {
-                            RENDERER[i].0
+                            RENDERER[i]
                         })
                         .changed();
 

ray-tracing-egui/src/render.rs

@@ -5,7 +5,10 @@ use std::sync::{
 
 use rand::{rngs::SmallRng, SeedableRng};
 use ray_tracing_core::{
-    camera::BasicCamera, prelude::*, renderer::ClassicalRenderer, scene::Scene,
+    camera::{BasicCamera, Camera},
+    prelude::*,
+    renderer::ClassicalRenderer,
+    scene::Scene,
 };
 use ray_tracing_renderer::{
     depth_renderer::DepthRenderer, mis::MIS, next_event_estimation::NextEventEstimation,
@@ -21,25 +24,6 @@ use vulkano::{
     memory::allocator::{AllocationCreateInfo, MemoryAllocator, MemoryTypeFilter},
 };
 
-type DynRenderer =
-    dyn ClassicalRenderer<SmallRng, Box<dyn Scene<SmallRng> + Sync>, BasicCamera> + Sync;
-#[allow(clippy::type_complexity)]
-pub const RENDERER: [(&str, fn(u32, u32) -> Box<DynRenderer>); 5] = [
-    ("Depth", |w, h| {
-        Box::new(DepthRenderer::new(w, h)) as Box<DynRenderer>
-    }),
-    ("Path tracer", |w, h| {
-        Box::new(PathTracer::new(w, h)) as Box<DynRenderer>
-    }),
-    ("Path tracer importance", |w, h| {
-        Box::new(PathTracerImportance::new(w, h)) as Box<DynRenderer>
-    }),
-    ("Next event estimation", |w, h| {
-        Box::new(NextEventEstimation::new(w, h)) as Box<DynRenderer>
-    }),
-    ("MIS", |w, h| Box::new(MIS::new(w, h)) as Box<DynRenderer>),
-];
-
 #[derive(Debug, Clone)]
 pub struct RenderSettings {
     pub width: u32,
@@ -59,6 +43,74 @@ pub struct Data {
     pub buffer: Subbuffer<[f32]>,
 }
 
+fn render_pass<
+    R: ClassicalRenderer<SmallRng, S, BasicCamera> + std::marker::Sync,
+    S: Scene<SmallRng> + std::marker::Sync,
+>(
+    settings: &RenderSettings,
+    renderer: &R,
+    scene: &S,
+    camera: &BasicCamera,
+    samples: u32,
+    buffer: &mut [Float],
+) {
+    buffer.par_chunks_mut(3).enumerate().for_each(|(i, c)| {
+        let x = (i % settings.width as usize) as u32;
+        let y = (i / settings.width as usize) as u32;
+
+        let mut rng = SmallRng::seed_from_u64(
+            (x + y * settings.width) as u64
+                + (settings.width as u64 * settings.height as u64 * samples as u64),
+        );
+        let r = renderer.render_pixel(&scene, &camera, x, y, &mut rng);
+        c[0] += r.r();
+        c[1] += r.g();
+        c[2] += r.b();
+    });
+}
+
+#[allow(clippy::type_complexity)]
+pub const RENDERER: [&str; 5] = [
+    "Depth",
+    "Path tracer",
+    "Path tracer importance",
+    "Next event estimation",
+    "MIS",
+];
+
+fn render_pass_renderer<S: Scene<SmallRng> + Sync>(
+    settings: &RenderSettings,
+    scene: &S,
+    camera: &BasicCamera,
+    samples: u32,
+    buffer: &mut [Float],
+) {
+    match settings.renderer_id {
+        0 => {
+            let r = DepthRenderer::new(settings.width, settings.height);
+            render_pass(settings, &r, scene, camera, samples, buffer);
+        }
+        1 => {
+            let r = PathTracer::new(settings.width, settings.height);
+            render_pass(settings, &r, scene, camera, samples, buffer);
+        }
+        2 => {
+            let r = PathTracerImportance::new(settings.width, settings.height);
+            render_pass(settings, &r, scene, camera, samples, buffer);
+        }
+        3 => {
+            let r = NextEventEstimation::new(settings.width, settings.height);
+            render_pass(settings, &r, scene, camera, samples, buffer);
+        }
+        4 => {
+            let r = MIS::new(settings.width, settings.height);
+            render_pass(settings, &r, scene, camera, samples, buffer);
+        }
+
+        _ => panic!("Unknown renderer"),
+    }
+}
+
 pub fn render_thread(
     s: RenderSettings,
     rx: Receiver<RenderSettings>,
@@ -82,8 +134,6 @@ pub fn render_thread(
         settings.camera_horizontal_fov,
     );
 
-    let mut renderer = (RENDERER[settings.renderer_id].1)(settings.width, settings.height);
-
     let mut samples = 0;
     loop {
         while let Ok(s) = rx.try_recv() {
@@ -99,24 +149,17 @@ pub fn render_thread(
                 settings.camera_horizontal_fov,
             );
             buffer = vec![0.0; settings.width as usize * settings.height as usize * 3];
-            renderer = (RENDERER[settings.renderer_id].1)(settings.width, settings.height);
             samples = 0;
         }
 
-        buffer.par_chunks_mut(3).enumerate().for_each(|(i, c)| {
-            let x = (i % settings.width as usize) as u32;
-            let y = (i / settings.width as usize) as u32;
-
-            let mut rng = SmallRng::seed_from_u64(
-                (x + y * settings.width) as u64
-                    + (settings.width as u64 * settings.height as u64 * samples as u64),
-            );
-            let r = renderer.render_pixel(&scene, &camera, x, y, &mut rng);
-            c[0] += r.r();
-            c[1] += r.g();
-            c[2] += r.b();
-        });
-
+        match &scene {
+            examples::ExampleSceneEnum::AccelerationStructureScene(s) => {
+                render_pass_renderer(&settings, s, &camera, samples, &mut buffer)
+            }
+            examples::ExampleSceneEnum::TriangleBVH(s) => {
+                render_pass_renderer(&settings, s, &camera, samples, &mut buffer)
+            }
+        }
         samples += 1;
 
         let data = Data {