stocking

vec3.rs (5044B)

---

 use std::{
     fmt::{Debug, Display},
     ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub},
 };
 
 use crate::random::RandomNumberGenerator;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
 pub struct Vec3 {
     x: f64,
     y: f64,
     z: f64,
 }
 
 impl Vec3 {
     pub const fn new(x: f64, y: f64, z: f64) -> Self {
         Vec3 { x, y, z }
     }
 
     pub fn random(rng: &mut RandomNumberGenerator, min: f64, max: f64) -> Self {
         Vec3::new(
             rng.next_f64_in_range(min, max),
             rng.next_f64_in_range(min, max),
             rng.next_f64_in_range(min, max),
         )
     }
 
     pub fn random_unit(rng: &mut RandomNumberGenerator) -> Self {
         loop {
             let p = Vec3::random(rng, -1., 1.);
             let length_squared = p.length_squared();
             if 1e-160 < length_squared && length_squared <= 1. {
                 return p / length_squared.sqrt();
             }
         }
     }
 
     pub fn random_on_hemisphere(rng: &mut RandomNumberGenerator, normal: &Vec3) -> Self {
         let on_unit_sphere = Vec3::random_unit(rng);
         if on_unit_sphere.dot(normal) > 0. {
             on_unit_sphere
         } else {
             -on_unit_sphere
         }
     }
 
     pub fn random_in_unit_disk(rng: &mut RandomNumberGenerator) -> Self {
         loop {
             let p = Vec3::new(
                 rng.next_f64_in_range(-1., 1.),
                 rng.next_f64_in_range(-1., 1.),
                 0.,
             );
             if p.length_squared() < 1. {
                 return p;
             }
         }
     }
 
     pub const fn x(&self) -> f64 {
         self.x
     }
 
     pub const fn y(&self) -> f64 {
         self.y
     }
 
     pub const fn z(&self) -> f64 {
         self.z
     }
 
     pub const fn cross(&self, other: &Vec3) -> Vec3 {
         Vec3 {
             x: self.y * other.z - self.z * other.y,
             y: self.z * other.x - self.x * other.z,
             z: self.x * other.y - self.y * other.x,
         }
     }
 
     pub const fn dot(&self, other: &Vec3) -> f64 {
         self.x * other.x + self.y * other.y + self.z * other.z
     }
 
     pub fn length(&self) -> f64 {
         self.length_squared().sqrt()
     }
 
     pub fn length_squared(&self) -> f64 {
         self.x.powi(2) + self.y.powi(2) + self.z.powi(2)
     }
 
     pub fn unit(&self) -> Vec3 {
         *self / self.length()
     }
 
     pub fn near_zero(&self) -> bool {
         const THRESHOLD: f64 = 1e-8;
         self.x().abs() < THRESHOLD && self.y().abs() < THRESHOLD && self.z().abs() < THRESHOLD
     }
 
     pub fn reflect(&self, normal: &Vec3) -> Vec3 {
         *self - 2. * self.dot(normal) * *normal
     }
 
     pub fn refract(&self, normal: &Vec3, refractive_index_ratio: f64) -> Vec3 {
         let cosine_theta = (-*self).dot(normal).min(1.);
         let r_out_perpendicular = refractive_index_ratio * (*self + cosine_theta * *normal);
         let r_out_parallel = -(1. - r_out_perpendicular.length_squared()).abs().sqrt() * *normal;
         r_out_perpendicular + r_out_parallel
     }
 }
 
 impl Add for Vec3 {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
         Vec3 {
             x: self.x + rhs.x,
             y: self.y + rhs.y,
             z: self.z + rhs.z,
         }
     }
 }
 
 impl AddAssign for Vec3 {
     fn add_assign(&mut self, rhs: Self) {
         self.x += rhs.x;
         self.y += rhs.y;
         self.z += rhs.z;
     }
 }
 
 impl Display for Vec3 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{} {} {}", self.x, self.y, self.z)
     }
 }
 
 impl DivAssign<f64> for Vec3 {
     fn div_assign(&mut self, rhs: f64) {
         self.x /= rhs;
         self.y /= rhs;
         self.z /= rhs;
     }
 }
 
 impl Div<f64> for Vec3 {
     type Output = Vec3;
 
     fn div(self, rhs: f64) -> Self::Output {
         Vec3 {
             x: self.x / rhs,
             y: self.y / rhs,
             z: self.z / rhs,
         }
     }
 }
 
 impl MulAssign<f64> for Vec3 {
     fn mul_assign(&mut self, rhs: f64) {
         self.x *= rhs;
         self.y *= rhs;
         self.z *= rhs;
     }
 }
 
 impl Mul<f64> for Vec3 {
     type Output = Vec3;
 
     fn mul(self, rhs: f64) -> Self::Output {
         Vec3 {
             x: self.x * rhs,
             y: self.y * rhs,
             z: self.z * rhs,
         }
     }
 }
 
 impl Mul<Vec3> for f64 {
     type Output = Vec3;
 
     fn mul(self, rhs: Vec3) -> Self::Output {
         rhs * self
     }
 }
 
 impl Mul<Vec3> for Vec3 {
     type Output = Vec3;
 
     fn mul(self, rhs: Vec3) -> Self::Output {
         Vec3 {
             x: self.x * rhs.x,
             y: self.y * rhs.y,
             z: self.z * rhs.z,
         }
     }
 }
 
 impl Neg for Vec3 {
     type Output = Self;
 
     fn neg(self) -> Self::Output {
         Vec3 {
             x: -self.x,
             y: -self.y,
             z: -self.z,
         }
     }
 }
 
 impl Sub for Vec3 {
     type Output = Vec3;
 
     fn sub(self, rhs: Self) -> Self::Output {
         Vec3 {
             x: self.x - rhs.x,
             y: self.y - rhs.y,
             z: self.z - rhs.z,
         }
     }
 }