TRY-34 Szenen raytracen

Co-Authored-By: LesKlugi <[email protected]>

Author: 2 people

Cargo.toml

@@ -19,6 +19,7 @@ image = { version = "0.24.7", default-features = false, features = [
 log = "0.4.20"
 nalgebra = { version = "0.32.3", features = ["serde", "serde-serialize"] }
 obj = "0.10.2"
+ordered-float = "4.1.1"
 simplelog = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.8"

src/main.rs

@@ -17,6 +17,7 @@ use nalgebra::Vector3;
 use simplelog::*;
 use std::fs::File;
 
+mod raytracer;
 mod scene;
 
 pub type Color = Vector3<f32>;

src/raytracer.rs

@@ -1,134 +1,46 @@
 use nalgebra::{Point3, Vector3};
+use obj::Material;
+use ordered_float::OrderedFloat;
 
-use crate::scene::Scene;
-//use scene::object::Object;
-use std::f64;
-use rand::Rng;
-
-use crate::scene::object::Object;
-
+use crate::{scene::Scene, Color};
 
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Ray {
-    pub origin: Point3<f64>,
-    pub direction: Vector3<f64>,
-}
-pub struct Intersection {
-    pub point: Point3<f64>,
-    pub normal: Vector3<f64>,
-    pub t: f64,
+    pub origin: Point3<f32>,
+    pub direction: Vector3<f32>,
 }
 
-pub struct Raytracer<'a> {
-    pub scene: &'a Scene,
-    pub width: u32,
-    pub height: u32,
-    pub fov: f64,
-    pub background_color: Vector3<f64>,
-    pub max_depth: u32,
+#[derive(Debug, PartialEq)]
+pub struct Hit<'a> {
+    pub point: Point3<f32>,
+    pub normal: Vector3<f32>,
+    pub material: Option<&'a Material>,
 }
 
-impl Intersection {
-    pub fn new(point: Point3<f64>, normal: Vector3<f64>, t: f64) -> Self {
-        Intersection { point, normal, t }
-    }
+pub struct Raytracer<'a> {
+    scene: &'a Scene,
+    background_color: Color,
 }
 
-
-impl Raytracer<'_> {
-    pub fn trace_ray(&self, ray: &Ray, depth: u32) -> Vector3<f64> {
-        if depth > self.max_depth {
-            return self.background_color;
-        }
-
-        let mut closest_intersection: Option<Intersection> = None;
-        let mut closest_object: Option<&Object> = None;
-
-        for object in self.scene.objects.iter() {
-            if let Some(intersection) = object.intersect(ray) {
-                if closest_intersection.is_none() || intersection.t < closest_intersection.unwrap().t {
-                    closest_intersection = Some(intersection);
-                    closest_object = Some(object);
-                }
-            }
-        }
-
-        if let Some(intersection) = closest_intersection {
-            let object = closest_object.unwrap();
-            let mut color = Vector3::new(0.0, 0.0, 0.0);
-
-            for light in self.scene.lights.iter() {
-                let light_direction = (light.position - intersection.point).normalize();
-                let shadow_ray = Ray {
-                    origin: intersection.point + intersection.normal * 0.0001,
-                    direction: light_direction,
-                };
-
-                let mut in_shadow = false;
-                for object in self.scene.objects.iter() {
-                    if let Some(shadow_intersection) = object.intersect(&shadow_ray) {
-                        if shadow_intersection.t < (light.position - intersection.point).norm() {
-                            in_shadow = true;
-                            break;
-                        }
-                    }
-                }
-
-                if !in_shadow {
-                    let diffuse = object.material.diffuse;
-                    let specular = object.material.specular;
-                    let shininess = object.material.shininess;
-
-                    let light_intensity = light.intensity / (light.position - intersection.point).norm_squared();
-                    let diffuse_intensity = light_intensity * diffuse * intersection.normal.dot(&light_direction).max(0.0);
-                    let view_direction = -ray.direction.normalize();
-                    let half_vector = (light_direction + view_direction).normalize();
-                    let specular_intensity = light_intensity * specular * intersection.normal.dot(&half_vector).max(0.0).powf(shininess);
-
-                    color += light.color.component_mul(&(diffuse_intensity + specular_intensity));
-                }
-            }
-
-            let reflection_ray = Ray {
-                origin: intersection.point + intersection.normal * 0.0001,
-                direction: ray.direction - 2.0 * ray.direction.dot(&intersection.normal) * intersection.normal,
-            };
-
-            let reflection_color = self.trace_ray(&reflection_ray, depth + 1);
-            let reflection_intensity = object.material.reflection;
-            color = color * (1.0 - reflection_intensity) + reflection_color * reflection_intensity;
-
-            color
-        } else {
-            self.background_color
+impl<'a> Raytracer<'a> {
+    pub fn new(scene: &'a Scene, background_color: Vector3<f32>) -> Raytracer<'a> {
+        Raytracer {
+            scene,
+            background_color,
         }
     }
 
-    pub fn render(&self) -> Vec<Vector3<f64>> {
-        let mut rng = rand::thread_rng();
-        let mut pixels = vec![Vector3::new(0.0, 0.0, 0.0); (self.width * self.height) as usize];
-
-        for y in 0..self.height {
-            for x in 0..self.width {
-                let u = (x as f64 + rng.gen::<f64>()) / self.width as f64;
-                let v = (y as f64 + rng.gen::<f64>()) / self.height as f64;
-
-                let aspect_ratio = self.width as f64 / self.height as f64;
-                let fov_adjustment = (self.fov.to_radians() / 2.0).tan();
-                let sensor_x = (((x as f64 + 0.5) / self.width as f64) * 2.0 - 1.0) * aspect_ratio * fov_adjustment;
-                let sensor_y = (1.0 - ((y as f64 + 0.5) / self.height as f64) * 2.0) * fov_adjustment;
-
-                let direction = Vector3::new(sensor_x, sensor_y, -1.0).normalize();
-                let ray = Ray {
-                    origin: Point3::new(0.0, 0.0, 0.0),
-                    direction: direction,
-                };
-
-                let color = self.trace_ray(&ray, 0);
-                pixels[(y * self.width + x) as usize] = color;
-            }
-        }
+    fn raycast(&self, ray: Ray) -> Option<Hit> {
+        self.scene
+            .objects
+            .iter()
+            .filter_map(|o| o.intersect(ray))
+            .min_by_key(|h| OrderedFloat((h.point - ray.origin).norm()))
+    }
 
-        pixels
+    pub fn render(&self, ray: Ray) -> Color {
+        self.raycast(ray)
+            .map(|_| Color::new(1.0, 0.0, 0.0))
+            .unwrap_or(self.background_color)
     }
 }
-

src/scene/camera.rs

@@ -3,10 +3,10 @@ use serde::Deserialize;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Camera {
-    position: Point3<f32>,
-    direction: Vector3<f32>,
-    up: Vector3<f32>,
-    fov: f32,
+    pub position: Point3<f32>,
+    pub direction: Vector3<f32>,
+    pub up: Vector3<f32>,
+    pub fov: f32,
 }
 
 mod yaml {

src/scene/light.rs

@@ -5,9 +5,9 @@ use crate::Color;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Light {
-    position: Point3<f32>,
-    color: Color,
-    intensity: f32,
+    pub position: Point3<f32>,
+    pub color: Color,
+    pub intensity: f32,
 }
 
 impl<'de> Deserialize<'de> for Light {

src/scene/object.rs

@@ -1,7 +1,10 @@
 use anyhow::Context;
 use log::warn;
-use nalgebra::{Point, Similarity3, Vector3};
+use nalgebra::{Point, Point3, Similarity3, Vector3};
 use obj::Material;
+use ordered_float::OrderedFloat;
+
+use crate::raytracer::{Hit, Ray};
 
 use super::triangle::Triangle;
 
@@ -130,3 +133,36 @@ impl Object {
         })
     }
 }
+
+impl Object {
+    pub fn intersect(&self, ray: Ray) -> Option<Hit> {
+        // Transform ray into object space
+        let ray = Ray {
+            origin: self.transform.inverse_transform_point(&ray.origin),
+            direction: self.transform.inverse_transform_vector(&ray.direction),
+        };
+
+        self.triangles
+            .iter()
+            .filter_map(|t| t.intersect(ray).map(|h| (t, h)))
+            .map(|(t, (u, v, w))| {
+                let material = t.material_index.map(|i| &self.materials[i]);
+                let normal = ((t.a_normal * u) + (t.b_normal * v) + (t.c_normal * w)).normalize();
+                let point = Point3::from((t.a.coords * u) + (t.b.coords * v) + (t.c.coords * w));
+                Hit {
+                    point,
+                    normal,
+                    material,
+                }
+            })
+            .min_by_key(|h| OrderedFloat((h.point - ray.origin).norm()))
+            .map(|h| {
+                // Transform hit back into world space
+                Hit {
+                    point: self.transform.transform_point(&h.point),
+                    normal: self.transform.transform_vector(&h.normal),
+                    ..h
+                }
+            })
+    }
+}

src/scene/settings.rs

@@ -2,6 +2,6 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Settings {
-    max_bounces: usize,
-    samples: usize,
+    pub max_bounces: u32,
+    pub samples: u32,
 }

src/scene/triangle.rs

@@ -1,5 +1,7 @@
 use nalgebra::{Point3, Vector3};
 
+use crate::raytracer::Ray;
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct Triangle {
     pub a: Point3<f32>,
@@ -10,3 +12,42 @@ pub struct Triangle {
     pub c_normal: Vector3<f32>,
     pub material_index: Option<usize>,
 }
+
+impl Triangle {
+    /// return barycentric coordinates if ray intersects triangle
+    pub fn intersect(&self, ray: Ray) -> Option<(f32, f32, f32)> {
+        let edge1 = self.b - self.a;
+        let edge2 = self.c - self.a;
+        let h = ray.direction.cross(&edge2);
+        let a = edge1.dot(&h);
+
+        if a.abs() < 1e-8 {
+            return None; // This ray is parallel to this triangle.
+        }
+
+        let f = 1.0 / a;
+        let s = ray.origin - self.a;
+        let u = f * s.dot(&h);
+
+        if u < 0.0 || u > 1.0 {
+            return None; // The intersection point is outside the triangle.
+        }
+
+        let q = s.cross(&edge1);
+        let v = f * ray.direction.dot(&q);
+
+        if v < 0.0 || u + v > 1.0 {
+            return None; // The intersection point is outside the triangle.
+        }
+
+        let t = f * edge2.dot(&q);
+
+        if t > 1e-8 {
+            let w = 1.0 - u - v;
+
+            Some((u, v, w))
+        } else {
+            None
+        }
+    }
+}