From ae4dc2c21a2f78348c2cb12748f583b2e4aed23b Mon Sep 17 00:00:00 2001 From: hal8174 Date: Sat, 23 Aug 2025 13:36:07 +0200 Subject: [PATCH] Fix all warnings --- ray-tracing-core/src/material.rs | 16 +++- ray-tracing-core/src/math/pos3.rs | 2 +- ray-tracing-egui/src/render.rs | 19 +++-- ray-tracing-image/src/main.rs | 3 + ray-tracing-material/src/iridescent.rs | 2 +- ray-tracing-pbrt-scene/examples/pbrt-test.rs | 2 +- ray-tracing-pbrt-scene/src/either.rs | 12 +-- ray-tracing-pbrt-scene/src/lib.rs | 16 ++-- ray-tracing-pbrt-scene/src/material.rs | 39 +++++---- ray-tracing-pbrt-scene/src/scene.rs | 10 +-- ray-tracing-pbrt-scene/src/shape.rs | 37 ++++----- ray-tracing-pbrt-scene/src/texture.rs | 81 ++++++++++++++++--- .../src/texture/checkerboard.rs | 16 ++-- .../src/texture/imagemap.rs | 8 +- ray-tracing-pbrt-scene/src/texture/scale.rs | 10 +-- ray-tracing-pbrt-scene/src/tokenizer.rs | 13 +-- .../src/examples/basic_cornell.rs | 9 +-- ray-tracing-scene/src/examples/cornell2.rs | 2 +- ray-tracing-scene/src/examples/mis_test.rs | 2 +- ray-tracing-scene/src/examples/mod.rs | 23 +++--- .../src/examples/presentation_title_image.rs | 2 +- ray-tracing-scene/src/examples/sphere.rs | 61 +++++++------- .../src/examples/stanford_dragon.rs | 5 +- .../src/examples/stanford_dragon_as.rs | 18 ++--- ray-tracing-scene/src/parse_obj.rs | 18 ++--- ray-tracing-tev/src/main.rs | 8 +- 26 files changed, 249 insertions(+), 185 deletions(-) diff --git a/ray-tracing-core/src/material.rs b/ray-tracing-core/src/material.rs index f35c32b..782eb30 100644 --- a/ray-tracing-core/src/material.rs +++ b/ray-tracing-core/src/material.rs @@ -1,5 +1,5 @@ use crate::prelude::*; -use std::fmt::Debug; +use std::{fmt::Debug, ops::Deref}; /// Trait to model bxdf. /// @@ -55,6 +55,20 @@ impl> Material for &M { } } +impl Material for std::sync::Arc> { + fn eval(&self, w_in: Dir3, w_out: Dir3, rng: &mut R) -> Color { + self.deref().eval(w_in, w_out, rng) + } + + fn sample(&self, w_in: Dir3, rng: &mut R) -> SampleResult { + self.deref().sample(w_in, rng) + } + + fn pdf(&self, w_in: Dir3, w_out: Dir3) -> Float { + self.deref().pdf(w_in, w_out) + } +} + #[derive(Debug)] pub struct SampleResult { w_out: Dir3, diff --git a/ray-tracing-core/src/math/pos3.rs b/ray-tracing-core/src/math/pos3.rs index 4c2dcdf..eb935c9 100644 --- a/ray-tracing-core/src/math/pos3.rs +++ b/ray-tracing-core/src/math/pos3.rs @@ -1,6 +1,6 @@ use crate::prelude::*; use core::panic; -use std::ops::{Add, Index, Mul, Sub}; +use std::ops::{Add, Index, Sub}; #[derive(Debug, Clone, Copy)] pub struct Pos3 { diff --git a/ray-tracing-egui/src/render.rs b/ray-tracing-egui/src/render.rs index 57f9331..fb15917 100644 --- a/ray-tracing-egui/src/render.rs +++ b/ray-tracing-egui/src/render.rs @@ -1,14 +1,6 @@ -use std::sync::{ - mpsc::{Receiver, Sender}, - Arc, -}; - use rand::{rngs::SmallRng, SeedableRng}; use ray_tracing_core::{ - camera::{BasicCamera, Camera}, - prelude::*, - renderer::ClassicalRenderer, - scene::Scene, + camera::BasicCamera, prelude::*, renderer::ClassicalRenderer, scene::Scene, }; use ray_tracing_renderer::{ depth_renderer::DepthRenderer, mis::MIS, next_event_estimation::NextEventEstimation, @@ -19,6 +11,10 @@ use rayon::{ iter::{IndexedParallelIterator, ParallelIterator}, slice::ParallelSliceMut, }; +use std::sync::{ + mpsc::{Receiver, Sender}, + Arc, +}; use vulkano::{ buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer}, memory::allocator::{AllocationCreateInfo, MemoryAllocator, MemoryTypeFilter}, @@ -62,7 +58,7 @@ fn render_pass< (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); + let r = renderer.render_pixel(scene, camera, x, y, &mut rng); c[0] += r.r(); c[1] += r.g(); c[2] += r.b(); @@ -159,6 +155,9 @@ pub fn render_thread( examples::ExampleSceneEnum::TriangleBVH(s) => { render_pass_renderer(&settings, s, &camera, samples, &mut buffer) } + examples::ExampleSceneEnum::BasicScene(s) => { + render_pass_renderer(&settings, s, &camera, samples, &mut buffer) + } } samples += 1; diff --git a/ray-tracing-image/src/main.rs b/ray-tracing-image/src/main.rs index 416b5ef..859a997 100644 --- a/ray-tracing-image/src/main.rs +++ b/ray-tracing-image/src/main.rs @@ -66,5 +66,8 @@ fn main() -> ImageResult<()> { ray_tracing_scene::examples::ExampleSceneEnum::TriangleBVH(s) => { render_image(&r, s, &c, "test.exr", 1048) } + ray_tracing_scene::examples::ExampleSceneEnum::BasicScene(s) => { + render_image(&r, s, &c, "test.exr", 1048) + } } } diff --git a/ray-tracing-material/src/iridescent.rs b/ray-tracing-material/src/iridescent.rs index a40363c..8f23b29 100644 --- a/ray-tracing-material/src/iridescent.rs +++ b/ray-tracing-material/src/iridescent.rs @@ -36,7 +36,7 @@ impl Iridescent { let phi = 2.0 * f32::consts::PI * self.n2 * self.d2 * theta2.cos() / l; let num_real = r12 * (1.0 - f32::cos(-2.0 * phi)); - let num_imag = r12 * (-1.0 * f32::sin(-2.0 * phi)); + let num_imag = r12 * -f32::sin(-2.0 * phi); let denom_real = 1.0 - r12 * r12 * f32::cos(-2.0 * phi); let denom_imag = 0.0 - r12 * r12 * f32::sin(-2.0 * phi); diff --git a/ray-tracing-pbrt-scene/examples/pbrt-test.rs b/ray-tracing-pbrt-scene/examples/pbrt-test.rs index a49cfc6..ac9d964 100644 --- a/ray-tracing-pbrt-scene/examples/pbrt-test.rs +++ b/ray-tracing-pbrt-scene/examples/pbrt-test.rs @@ -10,7 +10,7 @@ struct Args { fn main() -> Result<(), miette::Error> { let args = Args::parse(); - let t = parse_pbrt_v4(args.filename)?; + let _t = parse_pbrt_v4(args.filename)?; // dbg!(t); diff --git a/ray-tracing-pbrt-scene/src/either.rs b/ray-tracing-pbrt-scene/src/either.rs index 9faabf7..1ee8cfa 100644 --- a/ray-tracing-pbrt-scene/src/either.rs +++ b/ray-tracing-pbrt-scene/src/either.rs @@ -5,12 +5,12 @@ pub enum Either { } impl Either { - pub fn map_a(self, f: impl FnOnce(A) -> C) -> Either { - match self { - Either::A(a) => Either::A(f(a)), - Either::B(b) => Either::B(b), - } - } + // pub fn map_a(self, f: impl FnOnce(A) -> C) -> Either { + // match self { + // Either::A(a) => Either::A(f(a)), + // Either::B(b) => Either::B(b), + // } + // } pub fn map_b(self, f: impl FnOnce(B) -> C) -> Either { match self { Either::A(a) => Either::A(a), diff --git a/ray-tracing-pbrt-scene/src/lib.rs b/ray-tracing-pbrt-scene/src/lib.rs index d2d9c66..6d858c9 100644 --- a/ray-tracing-pbrt-scene/src/lib.rs +++ b/ray-tracing-pbrt-scene/src/lib.rs @@ -1,12 +1,10 @@ use crate::{ scene::PbrtScene, shape::{Shape, ShapeAlpha, ShapeType}, - texture::Pbrt_2d_float_texture, tokenizer::Tokenizer, }; -use error::SourceFile; use material::PbrtMaterial; -use miette::{Diagnostic, IntoDiagnostic, Result, SourceSpan, bail, miette}; +use miette::{IntoDiagnostic, Result, bail, miette}; use ray_tracing_core::{ affine_transform::AffineTransform, math::{Dir3, Pos3}, @@ -18,7 +16,6 @@ use std::{ sync::Arc, }; use texture::PbrtTexture; -use thiserror::Error; #[macro_use] mod tokenizer; @@ -43,6 +40,7 @@ impl Lexer { } #[derive(Debug)] +#[allow(dead_code)] enum CameraType { Orthographic { frame_aspect_ratio: Option, @@ -60,6 +58,7 @@ enum CameraType { } #[derive(Debug)] +#[allow(dead_code)] struct PbrtCamera { camera_type: CameraType, shutter_open: Float, @@ -465,8 +464,8 @@ fn parse_transform(input: &mut Tokenizer) -> Result { let mut v = [0.0; 16]; - for i in 0..16 { - v[i] = input + for i in &mut v { + *i = input .next() .ok_or(miette!("value expected"))?? .parse::() @@ -618,7 +617,8 @@ impl Pbrt { } #[derive(Debug)] -struct PbrtWorldSettings { +#[allow(dead_code)] +pub struct PbrtWorldSettings { camera: PbrtCamera, camera_ctm: AffineTransform, } @@ -747,7 +747,7 @@ fn inner_parse_pbrt(path: impl AsRef + std::fmt::Debug) -> Result { match p { Statement::AttributeBegin => context.push(), Statement::AttributeEnd => { - context.pop(); + context.pop()?; } Statement::Include(_) => unreachable!(), Statement::ConcatTransform(affine_transform) => { diff --git a/ray-tracing-pbrt-scene/src/material.rs b/ray-tracing-pbrt-scene/src/material.rs index 2714ed9..933993d 100644 --- a/ray-tracing-pbrt-scene/src/material.rs +++ b/ray-tracing-pbrt-scene/src/material.rs @@ -2,7 +2,7 @@ use ray_tracing_core::color::Color; use crate::{ either::Either, - texture::{Pbrt_2d_float_texture, Pbrt_2d_spectrum_texture, parse_rgb}, + texture::{Pbrt2dFloatTexture, Pbrt2dSpectrumTexture, parse_rgb}, }; use super::*; @@ -24,40 +24,45 @@ pub fn parse_make_named_material( } #[derive(Debug)] +#[allow(dead_code)] struct PbrtCoatedDiffuseMaterial { - albedo: Either>, - g: Either>, + albedo: Either>, + g: Either>, maxdepth: usize, nsamples: usize, thickness: Float, - roughness: Either>, - uroughness: Either>, - vroughness: Either>, - reflectance: Either>, + roughness: Either>, + uroughness: Either>, + vroughness: Either>, + reflectance: Either>, + #[allow(clippy::type_complexity)] eta: Either< - Either>, - Either>, + Either>, + Either>, >, } impl PbrtMaterial for PbrtCoatedDiffuseMaterial {} #[derive(Debug)] +#[allow(dead_code)] struct PbrtDielectricMaterial { + #[allow(clippy::type_complexity)] eta: Either< - Either>, - Either>, + Either>, + Either>, >, - roughness: Either>, - uroughness: Either>, - vroughness: Either>, + roughness: Either>, + uroughness: Either>, + vroughness: Either>, } impl PbrtMaterial for PbrtDielectricMaterial {} #[derive(Debug)] +#[allow(dead_code)] struct PbrtDiffuseMaterial { - reflectance: Either>, + reflectance: Either>, } impl PbrtMaterial for PbrtDiffuseMaterial {} @@ -65,7 +70,7 @@ impl PbrtMaterial for PbrtDiffuseMaterial {} fn parse_2d_float_texture( input: &mut Tokenizer, context: &PbrtContext, -) -> Result> { +) -> Result> { let n = input.parse_parameter()?; context @@ -77,7 +82,7 @@ fn parse_2d_float_texture( fn parse_2d_spectrum_texture( input: &mut Tokenizer, context: &PbrtContext, -) -> Result> { +) -> Result> { let n = input.parse_parameter()?; context diff --git a/ray-tracing-pbrt-scene/src/scene.rs b/ray-tracing-pbrt-scene/src/scene.rs index 5fe86af..7a95e4a 100644 --- a/ray-tracing-pbrt-scene/src/scene.rs +++ b/ray-tracing-pbrt-scene/src/scene.rs @@ -17,11 +17,11 @@ impl Scene for PbrtScene { R: 'a; fn intersect( - &self, + &'_ self, ray: ray_tracing_core::prelude::Ray, min: ray_tracing_core::prelude::Float, max: ray_tracing_core::prelude::Float, - ) -> Option>> { + ) -> Option>> { let mut i = None; for s in &self.shapes { if let Some(new_i) = s.intersect::(ray, min, max) @@ -40,9 +40,9 @@ impl Scene for PbrtScene { fn sample_light<'b>( &self, - w_in: ray_tracing_core::prelude::Dir3, - intersection: &ray_tracing_core::scene::Intersection<'_, R, Self::Mat<'b>>, - rng: &mut R, + _w_in: ray_tracing_core::prelude::Dir3, + _intersection: &ray_tracing_core::scene::Intersection<'_, R, Self::Mat<'b>>, + _rng: &mut R, ) -> Option> where Self: 'b, diff --git a/ray-tracing-pbrt-scene/src/shape.rs b/ray-tracing-pbrt-scene/src/shape.rs index a3c228f..c6630ff 100644 --- a/ray-tracing-pbrt-scene/src/shape.rs +++ b/ray-tracing-pbrt-scene/src/shape.rs @@ -5,6 +5,7 @@ use ray_tracing_core::{affine_transform::AffineTransform, prelude::*, scene::Int use crate::material::PbrtMaterial; #[derive(Debug)] +#[allow(dead_code)] pub(crate) struct Shape { pub(crate) ctm: AffineTransform, pub(crate) material: Arc, @@ -13,6 +14,7 @@ pub(crate) struct Shape { } #[derive(Debug)] +#[allow(dead_code)] pub(crate) enum ShapeAlpha { None, Value(Float), @@ -20,6 +22,7 @@ pub(crate) enum ShapeAlpha { } #[derive(Debug)] +#[allow(dead_code)] pub(crate) enum ShapeType { Sphere { radius: Float, @@ -115,7 +118,7 @@ fn bilinear_intersection( .into_iter() .flatten() .filter(|&u| { - if 0.0 <= u && u <= 1.0 { + if (0.0..=1.0).contains(&u) { return true; } false @@ -146,7 +149,7 @@ fn bilinear_intersection( - ud.x() * deltao.y() * perp.z() - perp.x() * ud.y() * deltao.z(); - if t1 > 0.0 && 0.0 < v1 && v1 <= p2 { + if t1 >= min && t1 <= max && 0.0 < v1 && v1 <= p2 { Some((t1 / p2, u, v1 / p2)) } else { None @@ -157,11 +160,11 @@ fn bilinear_intersection( impl Shape { pub(crate) fn intersect( - &self, + &'_ self, ray: Ray, min: Float, max: Float, - ) -> Option>> { + ) -> Option>> { let ray = self.ctm.transform_ray(ray); match &self.obj { @@ -220,14 +223,13 @@ impl Shape { } } } - ShapeType::TriangleMesh { + ShapeType::TriangleMesh { .. } => (), + ShapeType::BilinearMesh { indices, p, - n, - s, - uv, - } => (), - ShapeType::BilinearMesh { indices, p, n, uv } => { + n: _, + uv: _, + } => { if indices.is_empty() && let Some((t, _u, _v)) = bilinear_intersection(ray, min, max, [p[0], p[1], p[2], p[3]]) @@ -235,18 +237,9 @@ impl Shape { return Some(Intersection::new(t, Dir3::up(), None, None, 0.0)); } } - ShapeType::LoopSubDiv { levels, indices, p } => todo!(), - ShapeType::Disk { - height, - radius, - innerradius, - phimax, - } => (), - ShapeType::PlyMesh { - filename, - displacement, - edgelength, - } => (), + ShapeType::LoopSubDiv { .. } => todo!(), + ShapeType::Disk { .. } => (), + ShapeType::PlyMesh { .. } => (), } None diff --git a/ray-tracing-pbrt-scene/src/texture.rs b/ray-tracing-pbrt-scene/src/texture.rs index 5d495d8..ef4afd8 100644 --- a/ray-tracing-pbrt-scene/src/texture.rs +++ b/ray-tracing-pbrt-scene/src/texture.rs @@ -1,10 +1,9 @@ +use crate::{PbrtContext, either::Either, tokenizer::Tokenizer}; use imagemap::{ImageMapEncoding, ImageMapWrap, SpectrumImageMapTexture}; use miette::{Result, miette}; -use ray_tracing_core::{affine_transform::AffineTransform, color::Color, prelude::Float}; +use ray_tracing_core::{color::Color, prelude::Float}; use scale::SpectrumScaleTexture2d; -use std::{collections::HashMap, ops::Deref, sync::Arc}; - -use crate::{PbrtContext, either::Either, tokenizer::Tokenizer}; +use std::sync::Arc; mod checkerboard; mod imagemap; @@ -12,20 +11,20 @@ mod scale; pub trait PbrtTexture: std::fmt::Debug + Send + Sync { fn get_dimension(&self) -> TextureDimension; - fn get_2d_float_texture(self: Arc) -> Result>; - fn get_2d_spectrum_texture(self: Arc) -> Result>; + fn get_2d_float_texture(self: Arc) -> Result>; + fn get_2d_spectrum_texture(self: Arc) -> Result>; } -pub trait Pbrt_2d_float_texture: std::fmt::Debug + Sync + Send { +pub trait Pbrt2dFloatTexture: std::fmt::Debug + Sync + Send { fn get(&self, u: Float, v: Float) -> Float; } -pub trait Pbrt_2d_spectrum_texture: std::fmt::Debug + Sync + Send { +pub trait Pbrt2dSpectrumTexture: std::fmt::Debug + Sync + Send { fn get(&self, u: Float, v: Float) -> Color; } #[derive(Debug)] -enum TextureDimension { +pub enum TextureDimension { D2, D3, } @@ -57,6 +56,7 @@ impl TextureMapping { } pub fn parse_spectrum(input: &mut Tokenizer) -> Result { + let _ = input; todo!() } @@ -71,8 +71,67 @@ fn parse_float_texture( ) -> Result> { let texture_class: String = input.parse_next()?; - dbg!(texture_class); - todo!() + match texture_class.as_str() { + "\"checkerboard\"" => { + let t = parse_dict!(input => + mapping, TextureMapping, TextureMapping::UV; + uscale, Float, 1.0; + vscale, Float, 1.0; + udelta, Float, 0.0; + vdelta, Float, 0.0; + dimension, TextureDimension, TextureDimension::D2; + tex1, Either, Either::A(1.0); + tex2, Either, Either::A(0.0) + => + mapping, "\"string mapping\"", TextureMapping::new(input.parse_parameter()?)?; + uscale, "\"float uscale\"", input.parse_parameter()?; + vscale, "\"float vscale\"", input.parse_parameter()?; + udelta, "\"float udelta\"", input.parse_parameter()?; + vdelta, "\"float vdelta\"", input.parse_parameter()?; + dimension, "\"integer dimension\"", TextureDimension::new(input.parse_parameter()?)?; + tex1, "\"float tex1\"", Either::A(input.parse_parameter()?); + tex1, "\"texture tex1\"", Either::B(input.parse_parameter()?); + tex2, "\"float tex2\"", Either::A(input.parse_parameter()?); + tex2, "\"texture tex2\"", Either::B(input.parse_parameter()?) + + ); + + let mapping = UVMapping::new(t.mapping, t.uscale, t.vscale, t.udelta, t.vdelta); + + match t.dimension { + TextureDimension::D2 => Ok(Arc::new(checkerboard::FloatCheckerboardTexture2d { + mapping, + tex: [ + t.tex1 + .map_b(|name| { + Arc::clone( + context + .get_texture(&name) + .ok_or_else(|| miette!("unable to find texture"))?, + ) + .get_2d_float_texture() + }) + .transpose_b()?, + t.tex2 + .map_b(|name| { + Arc::clone( + context + .get_texture(&name) + .ok_or_else(|| miette!("unable to find texture"))?, + ) + .get_2d_float_texture() + }) + .transpose_b()?, + ], + })), + TextureDimension::D3 => { + todo!() + } + } + } + + _ => Err(miette!("unknown error {texture_class}")), + } } fn parse_spectrum_texture( diff --git a/ray-tracing-pbrt-scene/src/texture/checkerboard.rs b/ray-tracing-pbrt-scene/src/texture/checkerboard.rs index 7fd5e3c..28052c9 100644 --- a/ray-tracing-pbrt-scene/src/texture/checkerboard.rs +++ b/ray-tracing-pbrt-scene/src/texture/checkerboard.rs @@ -3,10 +3,10 @@ use super::*; #[derive(Debug)] pub(super) struct FloatCheckerboardTexture2d { pub(super) mapping: UVMapping, - pub(super) tex: [Either>; 2], + pub(super) tex: [Either>; 2], } -impl Pbrt_2d_float_texture for FloatCheckerboardTexture2d { +impl Pbrt2dFloatTexture for FloatCheckerboardTexture2d { fn get(&self, u: Float, v: Float) -> Float { let (u, v) = self.mapping.map(u, v); @@ -28,11 +28,11 @@ impl Pbrt_2d_float_texture for FloatCheckerboardTexture2d { } impl PbrtTexture for FloatCheckerboardTexture2d { - fn get_2d_float_texture(self: Arc) -> Result> { + fn get_2d_float_texture(self: Arc) -> Result> { Ok(self) } - fn get_2d_spectrum_texture(self: Arc) -> Result> { + fn get_2d_spectrum_texture(self: Arc) -> Result> { Err(miette!("Unable to use this texture as a spectrum texture")) } @@ -43,10 +43,10 @@ impl PbrtTexture for FloatCheckerboardTexture2d { #[derive(Debug)] pub(super) struct SpectrumCheckerboardTexture2d { pub(super) mapping: UVMapping, - pub(super) tex: [Either>; 2], + pub(super) tex: [Either>; 2], } -impl Pbrt_2d_spectrum_texture for SpectrumCheckerboardTexture2d { +impl Pbrt2dSpectrumTexture for SpectrumCheckerboardTexture2d { fn get(&self, u: Float, v: Float) -> Color { let (u, v) = self.mapping.map(u, v); @@ -68,11 +68,11 @@ impl Pbrt_2d_spectrum_texture for SpectrumCheckerboardTexture2d { } impl PbrtTexture for SpectrumCheckerboardTexture2d { - fn get_2d_float_texture(self: Arc) -> Result> { + fn get_2d_float_texture(self: Arc) -> Result> { Err(miette!("Unable to use this texture as a float texture")) } - fn get_2d_spectrum_texture(self: Arc) -> Result> { + fn get_2d_spectrum_texture(self: Arc) -> Result> { Ok(self) } diff --git a/ray-tracing-pbrt-scene/src/texture/imagemap.rs b/ray-tracing-pbrt-scene/src/texture/imagemap.rs index 9a50c2d..a892179 100644 --- a/ray-tracing-pbrt-scene/src/texture/imagemap.rs +++ b/ray-tracing-pbrt-scene/src/texture/imagemap.rs @@ -24,6 +24,7 @@ impl ImageMapWrap { #[derive(Debug)] pub(super) enum ImageMapEncoding { + #[allow(clippy::upper_case_acronyms)] SRGB, Linear, Gamma(Float), @@ -118,22 +119,23 @@ impl SpectrumImageMapTexture { } } -impl Pbrt_2d_spectrum_texture for SpectrumImageMapTexture { +impl Pbrt2dSpectrumTexture for SpectrumImageMapTexture { fn get(&self, u: Float, v: Float) -> Color { let (u, v) = self.mapping.map(u, v); let (w, h) = self.image.dimensions(); + dbg!(u, v, w, h); todo!() } } impl PbrtTexture for SpectrumImageMapTexture { - fn get_2d_float_texture(self: Arc) -> Result> { + fn get_2d_float_texture(self: Arc) -> Result> { Err(miette!("Unable to use this texture as a float texture")) } - fn get_2d_spectrum_texture(self: Arc) -> Result> { + fn get_2d_spectrum_texture(self: Arc) -> Result> { Ok(self) } diff --git a/ray-tracing-pbrt-scene/src/texture/scale.rs b/ray-tracing-pbrt-scene/src/texture/scale.rs index ab3189f..6f8c580 100644 --- a/ray-tracing-pbrt-scene/src/texture/scale.rs +++ b/ray-tracing-pbrt-scene/src/texture/scale.rs @@ -2,8 +2,8 @@ use super::*; #[derive(Debug)] pub(super) struct SpectrumScaleTexture2d { - pub(super) tex: Either>, - pub(super) scale: Either>, + pub(super) tex: Either>, + pub(super) scale: Either>, } impl PbrtTexture for SpectrumScaleTexture2d { @@ -11,16 +11,16 @@ impl PbrtTexture for SpectrumScaleTexture2d { TextureDimension::D2 } - fn get_2d_float_texture(self: Arc) -> Result> { + fn get_2d_float_texture(self: Arc) -> Result> { Err(miette!("Unable to convert to float texture")) } - fn get_2d_spectrum_texture(self: Arc) -> Result> { + fn get_2d_spectrum_texture(self: Arc) -> Result> { Ok(self) } } -impl Pbrt_2d_spectrum_texture for SpectrumScaleTexture2d { +impl Pbrt2dSpectrumTexture for SpectrumScaleTexture2d { fn get(&self, u: Float, v: Float) -> Color { let x = match &self.tex { Either::A(x) => *x, diff --git a/ray-tracing-pbrt-scene/src/tokenizer.rs b/ray-tracing-pbrt-scene/src/tokenizer.rs index f7ff6e8..7fa1403 100644 --- a/ray-tracing-pbrt-scene/src/tokenizer.rs +++ b/ray-tracing-pbrt-scene/src/tokenizer.rs @@ -1,15 +1,10 @@ -use crate::{ - BytesToChar, PbrtContext, either::Either, error::SourceFile, texture::Pbrt_2d_float_texture, -}; -use const_format::concatcp; -use miette::{Diagnostic, Error, IntoDiagnostic, Report, Result, SourceSpan}; -use ray_tracing_core::prelude::Float; +use crate::{BytesToChar, error::SourceFile}; +use miette::{Diagnostic, IntoDiagnostic, Report, Result, SourceSpan}; use std::{ fs::File, io::{BufReader, Bytes, Read}, iter::Peekable, path::{Path, PathBuf}, - sync::Arc, }; use thiserror::Error; @@ -32,10 +27,6 @@ impl Tokenizer { }) } - pub fn get_path(&self) -> &Path { - &self.path - } - pub fn get_base_path(&self) -> &Path { &self.base_path } diff --git a/ray-tracing-scene/src/examples/basic_cornell.rs b/ray-tracing-scene/src/examples/basic_cornell.rs index e2df3eb..775f565 100644 --- a/ray-tracing-scene/src/examples/basic_cornell.rs +++ b/ray-tracing-scene/src/examples/basic_cornell.rs @@ -1,14 +1,11 @@ -use std::cell::OnceCell; - +use super::ExampleScene; use crate::{ examples::ExampleSceneEnum, triangle_bvh::{BVHMaterial, Triangle, TriangleBVH}, }; - -use super::ExampleScene; - -use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene}; +use ray_tracing_core::{light::AreaLight, prelude::*}; use ray_tracing_material::{diffuse::DiffuseMaterial, mirror::Mirror}; +use std::cell::OnceCell; pub struct BasicCornell { scene: OnceCell>, diff --git a/ray-tracing-scene/src/examples/cornell2.rs b/ray-tracing-scene/src/examples/cornell2.rs index 52cdb31..2bd825a 100644 --- a/ray-tracing-scene/src/examples/cornell2.rs +++ b/ray-tracing-scene/src/examples/cornell2.rs @@ -1,5 +1,5 @@ use rand::Rng; -use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene}; +use ray_tracing_core::{light::AreaLight, prelude::*}; use ray_tracing_material::{diffuse::DiffuseMaterial, mirror::Mirror}; use std::cell::OnceCell; diff --git a/ray-tracing-scene/src/examples/mis_test.rs b/ray-tracing-scene/src/examples/mis_test.rs index 38a606c..9986a5d 100644 --- a/ray-tracing-scene/src/examples/mis_test.rs +++ b/ray-tracing-scene/src/examples/mis_test.rs @@ -3,7 +3,7 @@ use crate::{ examples::ExampleSceneEnum, triangle_bvh::{BVHMaterial, Triangle, TriangleBVH}, }; -use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene}; +use ray_tracing_core::{light::AreaLight, prelude::*}; use ray_tracing_material::{ microfacet::{BeckmannDistribution, Microfacet}, mirror::Mirror, diff --git a/ray-tracing-scene/src/examples/mod.rs b/ray-tracing-scene/src/examples/mod.rs index d4f7c46..c337b90 100644 --- a/ray-tracing-scene/src/examples/mod.rs +++ b/ray-tracing-scene/src/examples/mod.rs @@ -1,17 +1,16 @@ -use ray_tracing_core::{prelude::*, scene::Scene}; -use ray_tracing_material::iridescent::Iridescent; -use ray_tracing_material::microfacet::{BeckmannDistribution, Microfacet}; -use ray_tracing_material::mirror::Mirror; -use std::collections::HashMap; -use std::fmt::Debug; - -use crate::acceleration_structure::triangle_bvh::TriangleBVH; -use crate::acceleration_structure::AccelerationStructureScene; -use crate::basic_scene::BasicScene; +use crate::acceleration_structure::{triangle_bvh::TriangleBVH, AccelerationStructureScene}; +use ray_tracing_core::prelude::*; +use ray_tracing_material::{ + iridescent::Iridescent, + microfacet::{BeckmannDistribution, Microfacet}, + mirror::Mirror, +}; +use std::{collections::HashMap, fmt::Debug, sync::Arc}; pub enum ExampleSceneEnum { AccelerationStructureScene(AccelerationStructureScene, R>), TriangleBVH(crate::triangle_bvh::TriangleBVH), + BasicScene(crate::basic_scene::BasicScene>>), } pub trait ExampleScene { @@ -59,8 +58,8 @@ pub fn example_scenes() -> HashMap<&'static str, Box { - scene: OnceCell>, +pub struct SphereScene { + scene: OnceCell>>>, material: Cell>, } -impl SphereScene { +impl SphereScene { pub fn new(material: M) -> Self { Self { scene: OnceCell::new(), @@ -17,33 +20,33 @@ impl SphereScene { } } -// impl ExampleScene for SphereScene -// where -// R: Rng + 'static, -// M: Material + Clone + 'static, -// M: Send + Sync, -// { -// fn get_scene(&self) -> ExampleSceneEnum { -// let s = self -// .scene -// .get_or_init(|| BasicScene::new(self.material.take().unwrap())); +impl ExampleScene for SphereScene +where + R: Rng + 'static, + M: Material + Clone + 'static, + M: Send + Sync, +{ + fn get_scene(&self) -> ExampleSceneEnum { + let s = self + .scene + .get_or_init(|| BasicScene::new(Arc::new(self.material.take().unwrap()))); -// ExampleSceneEnum::BasicScene(s.clone()) -// } + ExampleSceneEnum::BasicScene(s.clone()) + } -// fn get_camera_pos(&self) -> Pos3 { -// Pos3::new(5.0, 1.0, 0.0) -// } + fn get_camera_pos(&self) -> Pos3 { + Pos3::new(5.0, 1.0, 0.0) + } -// fn get_camera_look_at(&self) -> Pos3 { -// Pos3::new(0.0, 0.0, 0.0) -// } + fn get_camera_look_at(&self) -> Pos3 { + Pos3::new(0.0, 0.0, 0.0) + } -// fn get_camera_up(&self) -> Dir3 { -// Dir3::up() -// } + fn get_camera_up(&self) -> Dir3 { + Dir3::up() + } -// fn get_horizontal_fov(&self) -> Float { -// Float::to_radians(90.0) -// } -// } + fn get_horizontal_fov(&self) -> Float { + Float::to_radians(90.0) + } +} diff --git a/ray-tracing-scene/src/examples/stanford_dragon.rs b/ray-tracing-scene/src/examples/stanford_dragon.rs index 6bae783..a47aaec 100644 --- a/ray-tracing-scene/src/examples/stanford_dragon.rs +++ b/ray-tracing-scene/src/examples/stanford_dragon.rs @@ -1,15 +1,14 @@ +use super::ExampleScene; use crate::{ examples::ExampleSceneEnum, parse_obj::ObjData, triangle_bvh::{BVHMaterial, Triangle, TriangleBVH}, }; use rand::Rng; -use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene}; +use ray_tracing_core::{light::AreaLight, prelude::*}; use ray_tracing_material::oren_nayar::OrenNayar; use std::cell::{Cell, OnceCell}; -use super::ExampleScene; - pub struct StanfordDragon> { scene: OnceCell>, material: Cell>, diff --git a/ray-tracing-scene/src/examples/stanford_dragon_as.rs b/ray-tracing-scene/src/examples/stanford_dragon_as.rs index 447f2c5..a68ef94 100644 --- a/ray-tracing-scene/src/examples/stanford_dragon_as.rs +++ b/ray-tracing-scene/src/examples/stanford_dragon_as.rs @@ -1,11 +1,4 @@ -use rand::Rng; -use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene}; -use ray_tracing_material::{ - microfacet::{BeckmannDistribution, Microfacet}, - oren_nayar::OrenNayar, -}; -use std::cell::OnceCell; - +use super::ExampleScene; use crate::{ acceleration_structure::{ triangle_bvh::{Triangle, TriangleBVH}, @@ -14,8 +7,13 @@ use crate::{ examples::ExampleSceneEnum, parse_obj::ObjData, }; - -use super::ExampleScene; +use rand::Rng; +use ray_tracing_core::{light::AreaLight, prelude::*}; +use ray_tracing_material::{ + microfacet::{BeckmannDistribution, Microfacet}, + oren_nayar::OrenNayar, +}; +use std::cell::OnceCell; pub struct StanfordDragon { scene: OnceCell, R>>, diff --git a/ray-tracing-scene/src/parse_obj.rs b/ray-tracing-scene/src/parse_obj.rs index 5b4368f..37e5855 100644 --- a/ray-tracing-scene/src/parse_obj.rs +++ b/ray-tracing-scene/src/parse_obj.rs @@ -69,19 +69,19 @@ fn parse_float(i: &str) -> IResult<&str, Float> { double(i).map(|(i, f)| (i, f as Float)) } -fn parse_vertex(i: &str) -> IResult<&str, Line> { +fn parse_vertex(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let mut v = [0.0; 3]; let (i, _) = fill(parse_float, &mut v)(i)?; Ok((i, Line::Vertex(Pos3::new(v[0], v[1], v[2])))) } -fn parse_normal(i: &str) -> IResult<&str, Line> { +fn parse_normal(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let mut v = [0.0; 3]; let (i, _) = fill(parse_float, &mut v)(i)?; Ok((i, Line::Normal(Dir3::new(v[0], v[1], v[2])))) } -fn parse_texcoord(i: &str) -> IResult<&str, Line> { +fn parse_texcoord(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let mut v = [0.0; 2]; let (i, _) = fill(parse_float, &mut v)(i)?; Ok((i, Line::Texcoord(v))) @@ -125,7 +125,7 @@ fn face_vertex_normal_tex(i: &str) -> IResult<&str, (i32, i32, i32)> { Ok((i, (v, t, n))) } -fn parse_face(i: &str) -> IResult<&str, Line> { +fn parse_face(i: &'_ str) -> IResult<&'_ str, Line<'_>> { if let Ok((i, s)) = many1(face_vertex_normal_tex)(i) { if s.len() >= 3 { Ok(( @@ -198,17 +198,17 @@ fn parse_face(i: &str) -> IResult<&str, Line> { } } -fn parse_mtllib(i: &str) -> IResult<&str, Line> { +fn parse_mtllib(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let (i, s) = take_till(|c| c == ' ')(i)?; Ok((i, Line::Mtllib(s))) } -fn parse_mtl(i: &str) -> IResult<&str, Line> { +fn parse_mtl(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let (i, s) = take_till(|c| c == ' ')(i)?; Ok((i, Line::Material(s))) } -fn parse_line(i: &str) -> IResult<&str, Line> { +fn parse_line(i: &'_ str) -> IResult<&'_ str, Line<'_>> { let (i, ident) = parse_identifier(i)?; let (i, _) = remove_whitespace(i)?; match ident { @@ -250,12 +250,12 @@ enum MaterialsLine<'a> { Empty, } -fn parse_new_material(i: &str) -> IResult<&str, MaterialsLine> { +fn parse_new_material(i: &'_ str) -> IResult<&'_ str, MaterialsLine<'_>> { let (i, ident) = take_till1(|c| c == ' ')(i)?; Ok((i, MaterialsLine::Material(ident))) } -fn parse_line_material(i: &str) -> IResult<&str, MaterialsLine> { +fn parse_line_material(i: &'_ str) -> IResult<&'_ str, MaterialsLine<'_>> { let (i, ident) = parse_identifier(i)?; let (i, _) = remove_whitespace(i)?; match ident { diff --git a/ray-tracing-tev/src/main.rs b/ray-tracing-tev/src/main.rs index 9d46110..1ec709b 100644 --- a/ray-tracing-tev/src/main.rs +++ b/ray-tracing-tev/src/main.rs @@ -36,14 +36,13 @@ struct Args { } fn render_image< - 'sc, R: ClassicalRenderer + Sync, S: Scene + Sync, C: Camera + Sync, >( name: impl AsRef, renderer: &R, - scene: &'sc S, + scene: &S, camera: &C, samples_per_pixel: usize, tev: &mut TevClient, @@ -109,7 +108,7 @@ fn render_image< Ok(()) } -fn choose_renderer<'sc, S, C>(args: &Args, scene: &str, s: &'sc S, c: &C, tev: &mut TevClient) +fn choose_renderer(args: &Args, scene: &str, s: &S, c: &C, tev: &mut TevClient) where S: Scene + Sync, C: Camera + Sync, @@ -216,6 +215,9 @@ fn main() { ray_tracing_scene::examples::ExampleSceneEnum::TriangleBVH(s) => { choose_renderer(&args, scene, s, &c, &mut client); } + ray_tracing_scene::examples::ExampleSceneEnum::BasicScene(s) => { + choose_renderer(&args, scene, s, &c, &mut client); + } } }