Chap 15: triangles

README.md

@@ -8,6 +8,13 @@ This is a personal project.
 I'm learning Rust while working my way through Jamis Buck's 
 [The Ray Tracer Challenge](http://raytracerchallenge.com/)
 
+<details open>
+<summary>Chapter 15: triangles</summary>
+
+![clover_triangles](https://raw.githubusercontent.com/fremag/ray_tracer_rust/main/img/clover_triangles.png)
+
+</details>
+
 <details open>
 <summary>Demo #1</summary>
 

src/main.rs

@@ -19,6 +19,7 @@ use scenes::clover_scene::CloverScene;
 use scene::Scene;
 use crate::patterns::pattern::Pattern;
 use crate::scenes::basic_refraction_scene::BasicRefractionScene;
+use crate::scenes::clover_triangles_scene::CloverTriangleScene;
 use crate::scenes::cone_scene::ConeScene;
 use crate::scenes::cube_scene::CubeScene;
 use crate::scenes::cylinder_scene::CylinderScene;
@@ -37,8 +38,8 @@ fn main() {
     }
 
     println!("Start...");
-    let scene = CloverScene::new(0.0, 0.0, -9.0);
-    scene.render(800, 600, "e:\\tmp\\clover.ppm");
+    let scene = CloverTriangleScene::new(0.0, 0.0, -9.0);
+    scene.render(800, 600, "e:\\tmp\\clover_triangle.ppm");
     println!("Done.")
 }
 

src/ray_tracer.rs

@@ -3,6 +3,8 @@ use crate::object::{build_cylinder, Object};
 use crate::shapes::group::Group;
 use crate::core::transform::{scaling, translation};
 use crate::core::tuple::{point, Tuple, vector};
+use crate::shapes::shape::Shape;
+use crate::shapes::triangle::Triangle;
 
 pub fn make_cylinder(p1: Tuple, p2: Tuple, radius: Float) -> Object {
     let v = p2 - p1;
@@ -94,3 +96,40 @@ pub fn build_mesh(mesh: &Mesh, r: Float, close_u: bool, close_v: bool) -> Object
 
     Object::new_group(group)
 }
+
+pub fn build_mesh_tri(mesh: &Mesh, close_u: bool, close_v: bool) -> Object
+{
+    let mut group = Group::new();
+    let mut  m = mesh.m;
+    let mut n = mesh.n;
+    if !close_u
+    {
+        m -= 1;
+    }
+
+    if ! close_v
+    {
+        n -= 1;
+    }
+
+    for i in 0..n
+    {
+        let mut sub_group = Group::new();
+        for j in 0..m
+        {
+            let  p0 = mesh.points[i][j];
+            let next_i = (i + 1) % mesh.n;
+            let next_j = (j + 1) % mesh.m;
+            let p1 = mesh.points[next_i][next_j];
+            let tri1 = Triangle::new(p0, p1, mesh.points[i][next_j]);
+            let tri2 = Triangle::new(p0, p1, mesh.points[next_i][j]);
+            let object = Object::new(Shape::Triangle(tri1));
+            sub_group.add(object);
+            let object1 = Object::new(Shape::Triangle(tri2));
+            sub_group.add(object1);
+        }
+
+        group.add( Object::new_group(sub_group));
+    }
+    Object::new_group(group)
+}

src/scenes/clover_triangles_scene.rs

@@ -0,0 +1,57 @@
+use crate::camera::Camera;
+use crate::core::math::{Float, PI};
+use crate::core::transform::view_transform;
+use crate::core::tuple::{point, Tuple, vector};
+use crate::ray_tracer::{build_mesh_tri, curve_sweep_mesh};
+use crate::scene::Scene;
+use crate::world::World;
+
+pub struct CloverTriangleScene {
+    from_x: Float,
+    from_y: Float,
+    from_z: Float,
+}
+
+impl CloverTriangleScene {
+    pub fn new(from_x: Float, from_y: Float, from_z: Float
+    ) -> Self {
+        Self {
+            from_x,
+            from_y,
+            from_z
+        }
+    }
+}
+
+impl Scene for CloverTriangleScene {
+    fn get_world(&self) -> World {
+        const R1: Float = 1.0;
+        const R2: Float = 0.25;
+        let mut world = Self::init_world(false);
+        fn path_clover(t: Float) -> Tuple {
+            let x = R1 * ((2.0 * PI * t).cos() + 2.0 * (2.0 * PI * 2.0 * t).cos());
+            let y = R1 * ((2.0 * PI * t).sin() - 2.0 * (2.0 * PI * 2.0 * t).sin());
+            let z = 2.0 * R2 * (2.0 * PI * 3.0 * t).sin();
+            point(x, y, z)
+        }
+
+        fn curve_circle(_u: Float, v: Float) -> (Float, Float) {
+            let x = R2 * (2.0 * PI * v).cos();
+            let y = R2 * (2.0 * PI * v).sin();
+            (x, y)
+        }
+
+        let mesh = curve_sweep_mesh(80, 8, path_clover, curve_circle);
+        let mesh_obj = build_mesh_tri(&mesh, true, true);
+        world.objects.push(mesh_obj);
+        world
+    }
+
+    fn get_camera(&self, h_size: usize, v_size: usize) -> Camera {
+        let mut camera = Camera::new(h_size, v_size, PI / 3.0);
+        camera.set_transform(view_transform(point(self.from_x, self.from_y, self.from_z),
+                                            point(0.0, 0.0 ,0.0 ),
+                                            vector(0.0, 1.0, 0.0)));
+        camera
+    }
+}

src/scenes/mod.rs

@@ -7,3 +7,4 @@ pub mod basic_refraction_scene;
 pub mod refraction_sphere_scene;
 pub mod patterns_scene;
 pub mod stripe_pattern_scene;
+pub mod clover_triangles_scene;