csci5607/assignment-1/src/ray.rs

use crate::scene_data::{Cylinder, Sphere};
use crate::vec3::Vec3;

/// A normalized parametric Ray of the form (origin + direction * time)
///
/// That means at any time t: f64, the point represented by origin + direction *
/// time occurs on the ray.
#[derive(Debug)]
pub struct Ray {
  origin: Vec3,
  direction: Vec3,
}

impl Ray {
  /// Construct a ray from endpoints
  pub fn from_endpoints(start: Vec3, end: Vec3) -> Self {
    let delta = (end - start).unit();
    Ray {
      origin: start,
      direction: delta,
    }
  }

  /// Evaluate the ray at a certain point in time, yielding a point
  pub fn eval(&self, time: f64) -> Vec3 {
    self.origin + self.direction * time
  }

  /// Given a sphere, returns the first time at which this ray intersects the
  /// sphere.
  ///
  /// If there is no intersection point, returns None.
  pub fn intersects_sphere_at(&self, sphere: &Sphere) -> Option<f64> {
    let a = self.direction.x.powi(2)
      + self.direction.y.powi(2)
      + self.direction.z.powi(2);
    let b = 2.0
      * (self.direction.x * (self.origin.x - sphere.center.x)
        + self.direction.y * (self.origin.y - sphere.center.y)
        + self.direction.z * (self.origin.z - sphere.center.z));
    let c = (self.origin.x - sphere.center.x).powi(2)
      + (self.origin.y - sphere.center.y).powi(2)
      + (self.origin.z - sphere.center.z).powi(2)
      - sphere.radius.powi(2);
    let discriminant = b * b - 4.0 * a * c;

    match discriminant {
      // Discriminant < 0, means the equation has no solutions.
      d if d < 0.0 => return None,

      // Discriminant == 0
      d if d == 0.0 => {
        return Some(-b / (2.0 * a));
      }

      d if d > 0.0 => {
        let solution_1 = (-b + discriminant.sqrt()) / (2.0 * a);
        let solution_2 = (-b - discriminant.sqrt()) / (2.0 * a);

        return Some(solution_1.min(solution_2));
      }

      // Probably hit some NaN or Infinity value due to faulty inputs...
      _ => unreachable!("Invalid determinant value: {discriminant}"),
    }
  }

  /// Given a cylinder, returns the first time at which this ray intersects the
  /// cylinder.
  ///
  /// If there is no intersection point, returns None.
  pub fn intersects_cylinder_at(&self, cylinder: &Cylinder) -> Option<f64> {
    // TODO: Implement
    None
  }
}

#[cfg(test)]
mod tests {
  use crate::scene_data::Sphere;
  use crate::vec3::Vec3;

  use super::Ray;

  #[test]
  fn practice_problem_slide_154() {
    let ray = Ray {
      origin: Vec3::new(0.0, 0.0, 0.0),
      direction: Vec3::new(0.0, 0.0, -1.0),
    };
    let sphere = Sphere {
      center: Vec3::new(0.0, 0.0, -10.0),
      radius: 4.0,
    };

    let point = ray.intersects_sphere_at(&sphere).map(|t| ray.eval(t));

    // the intersection point in this case is (0, 0, -6)
    assert_eq!(point, Some(Vec3::new(0.0, 0.0, -6.0)));
  }

  #[test]
  fn practice_problem_slide_158() {
    let ray = Ray {
      origin: Vec3::new(0.0, 0.0, 0.0),
      direction: Vec3::new(0.0, 0.5, -1.0),
    };
    let sphere = Sphere {
      center: Vec3::new(0.0, 0.0, -10.0),
      radius: 4.0,
    };

    // oops! In this case, the ray does not intersect the sphere.
    assert_eq!(ray.intersects_sphere_at(&sphere), None);
  }
}