TRY-34 szenen raytracen (provisorisch)

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

@@ -0,0 +1,46 @@
+use nalgebra::{Point3, Vector3};
+use obj::Material;
+use ordered_float::OrderedFloat;
+
+use crate::{scene::Scene, Color};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Ray {
+    pub origin: Point3<f32>,
+    pub direction: Vector3<f32>,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Hit<'a> {
+    pub point: Point3<f32>,
+    pub normal: Vector3<f32>,
+    pub material: Option<&'a Material>,
+}
+
+pub struct Raytracer<'a> {
+    scene: &'a Scene,
+    background_color: Color,
+}
+
+impl<'a> Raytracer<'a> {
+    pub fn new(scene: &'a Scene, background_color: Vector3<f32>) -> Raytracer<'a> {
+        Raytracer {
+            scene,
+            background_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()))
+    }
+
+    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/mod.rs

@@ -12,10 +12,10 @@ mod triangle;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Scene {
-    objects: Vec<Object>,
-    lights: Vec<Light>,
-    camera: Camera,
-    settings: Settings,
+    pub objects: Vec<Object>,
+    pub lights: Vec<Light>,
+    pub camera: Camera,
+    pub settings: Settings,
 }
 
 impl<'de> Deserialize<'de> for Scene {

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
+        }
+    }
+}