hal8174/ray-tracing2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add scene and renderer selection to egui

Browse source
This commit is contained in:
hal8174 2024-11-28 17:59:46 +01:00
parent d4bf1845cb
commit 1bfef16afa
6 changed files with 200 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

18
ray-tracing-core/src/renderer.rs
View file

@ -1,3 +1,5 @@
use std::ops::Deref;
use crate::{camera::Camera, prelude::*, scene::Scene};
pub trait ClassicalRenderer<R: Rng, S: Scene<R>, C: Camera<R>> {
@ -5,3 +7,19 @@ pub trait ClassicalRenderer<R: Rng, S: Scene<R>, C: Camera<R>> {
fn width(&self) -> u32;
fn height(&self) -> u32;
}
impl<R: Rng, S: Scene<R>, C: Camera<R>, T: ClassicalRenderer<R, S, C> + ?Sized>
ClassicalRenderer<R, S, C> for Box<T>
{
fn render_pixel(&self, scene: &S, camera: &C, x: u32, y: u32, rng: &mut R) -> Color {
self.deref().render_pixel(scene, camera, x, y, rng)
}
fn width(&self) -> u32 {
self.deref().width()
}
fn height(&self) -> u32 {
self.deref().height()
}
}

17
ray-tracing-core/src/scene.rs
View file

@ -1,3 +1,5 @@
use std::ops::Deref;
use crate::prelude::*;
pub trait Scene<R: Rng> {
@ -91,3 +93,18 @@ impl<'sc, R: Rng> LightSample<'sc, R> {
Frame::from_normal(self.normal)
}
}
impl<T: Scene<R> + ?Sized, R: Rng> Scene<R> for Box<T> {
fn intersect(&self, ray: Ray, min: Float, max: Float) -> Option<Intersection<'_, R>> {
self.deref().intersect(ray, min, max)
}
fn sample_light(
&self,
w_in: Dir3,
intersection: &Intersection<'_, R>,
rng: &mut R,
) -> Option<LightSample<'_, R>> {
self.deref().sample_light(w_in, intersection, rng)
}
}

31
ray-tracing-egui/src/main.rs
View file

@ -1,5 +1,6 @@
use egui_winit_vulkano::{Gui, GuiConfig};
use render::render_thread;
use ray_tracing_scene::examples::example_scenes;
use render::{render_thread, RENDERER};
use setup::{get_compute_pipeline, get_framebuffers};
use std::sync::Arc;
use vulkano::{
@ -87,9 +88,13 @@ fn main() {
let (control_tx, control_rx) = std::sync::mpsc::channel();
let (data_tx, data_rx) = std::sync::mpsc::channel();
let scenes = example_scenes::<rand::rngs::SmallRng>();
let mut settings = render::RenderSettings {
width: window.inner_size().width,
height: window.inner_size().height,
scene: scenes.keys().next().unwrap(),
renderer_id: 0,
};
let send_settings = settings.clone();
@ -163,10 +168,28 @@ fn main() {
pipeline = get_compute_pipeline(device.clone(), cs.clone());
}
let mut settings_changed = false;
gui.immediate_ui(|gui| {
let ctx = gui.context();
egui::Window::new("panel").show(&ctx, |ui| {
ui.heading("fdjkslf");
ui.collapsing("Scene Settings:", |ui| {
egui::ComboBox::from_label("Scene")
.selected_text(settings.scene)
.show_ui(ui, |ui| {
for &label in scenes.keys() {
settings_changed |= ui
.selectable_value(&mut settings.scene, label, label)
.changed();
}
});
});
settings_changed |= egui::ComboBox::from_label("Renderer")
.selected_text(RENDERER[settings.renderer_id].0)
.show_index(ui, &mut settings.renderer_id, RENDERER.len(), |i| {
RENDERER[i].0
})
.changed();
ui.collapsing("Render Settings:", |ui| {
ui.label(format!("{:#?}", &settings));
@ -174,6 +197,10 @@ fn main() {
});
});
if settings_changed {
let _ = control_tx.send(settings.clone());
}
let (image_i, suboptimal, acquire_future) =
match swapchain::acquire_next_image(swapchain.clone(), None)
.map_err(Validated::unwrap)

38
ray-tracing-egui/src/render.rs
View file

@ -4,8 +4,11 @@ use std::sync::{
};
use rand::{rngs::SmallRng, SeedableRng};
use ray_tracing_core::{camera::BasicCamera, renderer::ClassicalRenderer};
use ray_tracing_renderer::path_tracer_importance::PathTracerImportance;
use ray_tracing_core::{camera::BasicCamera, renderer::ClassicalRenderer, scene::Scene};
use ray_tracing_renderer::{
depth_renderer::DepthRenderer, next_event_estimation::NextEventEstimation,
path_tracer::PathTracer, path_tracer_importance::PathTracerImportance,
};
use ray_tracing_scene::examples::{self, example_scenes, ExampleScene};
use rayon::{
iter::{IndexedParallelIterator, ParallelIterator},
@ -19,10 +22,29 @@ use vulkano::{
},
};
type DynRenderer =
dyn ClassicalRenderer<SmallRng, Box<dyn Scene<SmallRng> + Sync>, BasicCamera> + Sync;
pub const RENDERER: [(&str, fn(u32, u32) -> Box<DynRenderer>); 4] = [
("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>
}),
];
#[derive(Debug, Clone)]
pub struct RenderSettings {
pub width: u32,
pub height: u32,
pub scene: &'static str,
pub renderer_id: usize,
}
pub enum ControlMessages {
@ -46,9 +68,10 @@ pub fn render_thread(
let mut buffer = vec![0.0; settings.width as usize * settings.height as usize * 3];
let e = examples::cornell2();
let example_scenes = examples::example_scenes::<SmallRng>();
let scene = e.scene;
let e = example_scenes[settings.scene]();
let mut scene = (e.scene)();
let mut camera = BasicCamera::new(
settings.width,
@ -59,12 +82,15 @@ pub fn render_thread(
e.horizontal_fov,
);
let mut renderer = PathTracerImportance::new(settings.width, settings.height);
let mut renderer = (RENDERER[settings.renderer_id].1)(settings.width, settings.height);
let mut samples = 0;
loop {
while let Ok(s) = rx.try_recv() {
println!("Settings changed.");
settings = s;
let e = example_scenes[settings.scene]();
scene = (e.scene)();
camera = BasicCamera::new(
settings.width,
settings.height,
@ -74,7 +100,7 @@ pub fn render_thread(
e.horizontal_fov,
);
buffer = vec![0.0; settings.width as usize * settings.height as usize * 3];
renderer = PathTracerImportance::new(settings.width, settings.height);
renderer = (RENDERER[settings.renderer_id].1)(settings.width, settings.height);
samples = 0;
}

30
ray-tracing-scene/src/examples.rs
View file

@ -2,27 +2,29 @@ use crate::{
parse_obj::ObjData,
triangle_bvh::{BVHMaterial, Triangle, TriangleBVH},
};
use ray_tracing_core::{light::AreaLight, prelude::*};
use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene};
use ray_tracing_material::{diffuse::DiffuseMaterial, mirror::Mirror};
use std::collections::HashMap;
use std::fmt::Debug;
pub struct ExampleScene<R: Rng> {
pub scene: TriangleBVH<R>,
pub scene: fn() -> Box<dyn Scene<R> + Sync>,
pub camera_pos: Pos3,
pub camera_dir: Dir3,
pub camera_up: Dir3,
pub horizontal_fov: Float,
}
pub fn example_scenes<R: Rng + Debug>() -> HashMap<&'static str, fn() -> ExampleScene<R>> {
pub fn example_scenes<R: Rng + Debug + 'static>() -> HashMap<&'static str, fn() -> ExampleScene<R>>
{
let mut map: HashMap<&str, fn() -> ExampleScene<R>> = HashMap::new();
map.insert("basic_cornel", basic_cornell::<R>);
map.insert("cornel2", cornell2::<R>);
map
}
pub fn cornell2<R: Rng + Debug>() -> ExampleScene<R> {
pub fn cornell2<R: Rng + Debug + 'static>() -> ExampleScene<R> {
let f = || {
let obj = ObjData::new("ray-tracing-scene/obj/cornell_box.obj").unwrap();
let triangles = obj
@ -36,18 +38,24 @@ pub fn cornell2<R: Rng + Debug>() -> ExampleScene<R> {
.map(|m| match m.name.as_str() {
"white" => BVHMaterial::new_material(DiffuseMaterial::new(Color::white())),
"light" => BVHMaterial::new_light(AreaLight::new(Color::white() * 100.0)),
"blue" => BVHMaterial::new_material(DiffuseMaterial::new(Color::new(0.0, 0.0, 1.0))),
"blue" => {
BVHMaterial::new_material(DiffuseMaterial::new(Color::new(0.0, 0.0, 1.0)))
}
"red" => BVHMaterial::new_material(DiffuseMaterial::new(Color::new(1.0, 0.0, 0.0))),
"green" => BVHMaterial::new_material(DiffuseMaterial::new(Color::new(0.0, 1.0, 0.0))),
"green" => {
BVHMaterial::new_material(DiffuseMaterial::new(Color::new(0.0, 1.0, 0.0)))
}
"mirror" => BVHMaterial::new_material(Mirror::new(Color::white())),
_ => unreachable!(),
})
.collect();
let scene = TriangleBVH::new(obj.vertices, triangles, materials);
Box::new(scene) as Box<dyn Scene<R> + Sync>
};
ExampleScene {
scene,
scene: f,
camera_pos: Pos3::new(275.0, 275.0, -800.0),
camera_dir: Dir3::new(0.0, 0.0, 1.0),
camera_up: Dir3::up(),
@ -55,7 +63,8 @@ pub fn cornell2<R: Rng + Debug>() -> ExampleScene<R> {
}
}
pub fn basic_cornell<R: Rng>() -> ExampleScene<R> {
pub fn basic_cornell<R: Rng + 'static>() -> ExampleScene<R> {
let f = || {
let side_length = 1.5;
let light_size = 0.5;
let light_offset = 0.01;
@ -122,8 +131,11 @@ pub fn basic_cornell<R: Rng>() -> ExampleScene<R> {
],
);
Box::new(scene) as Box<dyn Scene<R> + Sync>
};
ExampleScene {
scene,
scene: f,
camera_pos: Pos3::new(-6.0, 0.0, 0.0),
camera_dir: Dir3::new(1.0, 0.0, 0.0),
camera_up: Dir3::up(),

2
ray-tracing-tev/src/main.rs
View file

@ -107,7 +107,7 @@ fn main() {
e.camera_up,
e.horizontal_fov,
);
let s = e.scene;
let s = (e.scene)();
let r = DepthRenderer::new(args.width, args.height);
render_image(