raytracer 0.2.2

use std::ops::{
    Neg,
    Add, Sub,
    Mul, Div,
    AddAssign, SubAssign,
    MulAssign, DivAssign
};


/// This struct represents a mathematical vector.
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32
}

impl Vec3 {
    /// Vector constructor. Consider using a shorthand [`vec3!`]
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::Vec3;
    /// let v = Vec3::new(1.0, 2.0, 3.0);
    ///
    /// assert_eq!(v.x, 1.0);
    /// assert_eq!(v.y, 2.0);
    /// assert_eq!(v.z, 3.0);
    /// ```
    ///
    /// [`vec3!`]: ../macro.vec3.html
    pub fn new(x: f32, y: f32, z: f32) -> Vec3 {
        Vec3 {x, y, z}
    }

    /// Returns dot product between current and other vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, dot};
    /// let a = vec3!(1.0, 2.0, 3.0);
    /// let b = vec3!(3.0, 2.0, 1.0);
    ///
    /// assert_eq!(a.dot(b), 10.0);
    /// ```
    pub fn dot(self, other: Vec3) -> f32 {
        self.x * other.x + self.y * other.y + self.z * other.z
    }

    /// Returns cross product between current and other vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, cross};
    /// let i = vec3!(1.0, 0.0, 0.0);
    /// let j = vec3!(0.0, 1.0, 0.0);
    /// let k = vec3!(0.0, 0.0, 1.0);
    ///
    /// assert_eq!(i.cross(j),  k);
    /// assert_eq!(j.cross(i), -k);
    /// ```
    pub fn cross(self, other: Vec3) -> Vec3 {
        Vec3::new(
            self.y * other.z - self.z * other.y,
            self.z * other.x - self.x * other.z,
            self.x * other.y - self.y * other.x
        )
    }

    /// Returns magnitude of this vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, len};
    /// let v = vec3!(3.0, 4.0, 0.0);
    ///
    /// assert_eq!(v.len(), 5.0);
    /// ```
    pub fn len(self) -> f32 {
        (self.x * self.x + self.y * self.y + self.z * self.z).sqrt()
    }

    /// Returns squared magnitude of this vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, len_sqr};
    /// let v = vec3!(3.0, 4.0, 0.0);
    ///
    /// assert_eq!(v.len_sqr(), 25.0);
    /// ```
    pub fn len_sqr(self) -> f32 {
        self.x * self.x + self.y * self.y + self.z * self.z
    }

    /// Returns normalized version of this vector.
    ///
    /// Important: it does not alter original vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, normalize};
    /// let a = vec3!(10.0, 0.0, 0.0);
    /// let b = a.normalize();
    ///
    /// assert_ne!(a, b);
    ///
    /// assert_eq!(a, vec3!(10.0, 0.0, 0.0));
    /// assert_eq!(b, vec3!(1.0, 0.0, 0.0));
    /// ```
    pub fn normalize(self) -> Vec3 {
        let k = self.len().recip();
        Vec3::new(self.x * k, self.y * k, self.z * k)
    }

    /// Returns reflected vector.
    ///
    /// * `normal` - Normal of the surface.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, reflect};
    /// // reflective surface
    /// let normal = vec3!(0.0, 1.0, 0.0);
    ///
    /// // Reflection when ray is perpendicular
    /// let incident = vec3!(0.0, -1.0, 0.0);
    /// assert_eq!(incident.reflect(normal), vec3!(0.0, 1.0, 0.0));
    ///
    /// // Incident ray coming at 45 degree angle
    /// let incident = vec3!(-1.0, -1.0, 0.0);
    /// assert_eq!(incident.reflect(normal), vec3!(-1.0, 1.0, 0.0));
    /// ```
    pub fn reflect(self, normal: Vec3) -> Vec3 {
        self - 2f32 * self.dot(normal) * normal
    }

    /// Returns refracted vector.
    ///
    /// At critical angles (typically nearing 0), refraction is impossible. In such case,
    /// this function returns `None`.
    ///
    /// * `normal` - Normal of the surface.
    /// * `eta` - η₁ / η₂ of refraction indexes, where η₁ is the material
    /// that is being entered by the ray.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::{vec3, refract};
    /// // Glass surface
    /// let n = 1.5; // η₁ / η₂, where η₁ = 1.5 (glass) and η₂ = 1.0 (air)
    /// let normal = vec3!(0.0, 1.0, 0.0);
    ///
    /// // Rays perpendicular to the surface aren't affected by refraction
    /// let incident = vec3!(0.0, -1.0, 0.0);
    /// assert_eq!(incident.refract(normal, n), Some(incident));
    ///
    /// // Rays coming from an angle are refracted
    /// let incident = vec3!(-0.7, -1.0, 0.0);
    /// assert_eq!(incident.refract(normal, n), Some(vec3!(-0.86019355, -0.5099678, 0.0)));
    ///
    /// // At critical angles (nearing 0), rays aren't refracted, only reflected
    /// let incident = vec3!(-1.0, -0.05, 0.0);
    /// assert_eq!(incident.refract(normal, n), None); // from outside of the surface
    ///
    /// let incident = vec3!(1.0, 0.05, 0.0);
    /// assert_eq!(incident.refract(normal, n), None); // from inside of the surface
    /// ```
    pub fn refract(self, normal: Vec3, eta: f32) -> Option<Vec3> {
        let unit = self.normalize();
        let dt = unit.dot(normal);
        let discriminant = 1f32 - eta * eta * (1f32 - dt * dt);

        match discriminant > 0f32 {
            true  => Some(eta * (unit - normal * dt) - normal * discriminant.sqrt()),
            false => None
        }
    }
}


impl Neg for Vec3 {
    type Output = Vec3;
    /// Negates each vector component.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(1.0, 2.5, 7.0);
    /// let b = -a;
    ///
    /// assert_eq!(b.x, -a.x);
    /// assert_eq!(b.y, -a.y);
    /// assert_eq!(b.z, -a.z);
    /// ```
    fn neg(self) -> Self::Output {
        Vec3 {
            x: -self.x,
            y: -self.y,
            z: -self.z
        }
    }
}


impl Add<Vec3> for Vec3 {
    type Output = Vec3;
    /// Sums vector components.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(1.0, 2.0, 5.0);
    /// let b = vec3!(2.0, 4.0, 5.0);
    ///
    /// assert_eq!(a + b, vec3!(3.0, 6.0, 10.0));
    /// ```
    fn add(self, other: Vec3) -> Self::Output {
        Vec3 {
            x: self.x + other.x,
            y: self.y + other.y,
            z: self.z + other.z
        }
    }
}


impl Sub<Vec3> for Vec3 {
    type Output = Vec3;
    /// Subtracts vector components.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(1.0, 2.0, 3.0);
    /// let b = vec3!(0.5);
    ///
    /// assert_eq!(a - b, vec3!(0.5, 1.5, 2.5));
    /// ```
    fn sub(self, other: Vec3) -> Self::Output {
        Vec3 {
            x: self.x - other.x,
            y: self.y - other.y,
            z: self.z - other.z
        }
    }
}


impl Mul<Vec3> for Vec3 {
    type Output = Vec3;
    /// Multiplies vector components. This is NOT a dot product.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(1.0, 2.0, 3.0);
    /// let b = vec3!(2.0);
    ///
    /// assert_eq!(a * b, vec3!(2.0, 4.0, 6.0));
    /// ```
    fn mul(self, other: Vec3) -> Self::Output {
        Vec3 {
            x: self.x * other.x,
            y: self.y * other.y,
            z: self.z * other.z
        }
    }
}

impl Mul<f32> for Vec3 {
    type Output = Vec3;
    /// Multiplies each vector component by scalar.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let v = vec3!(1.0, 2.0, 3.0);
    /// let s = 3.0;
    ///
    /// assert_eq!(v * s, vec3!(3.0, 6.0, 9.0))
    /// ```
    fn mul(self, other: f32) -> Self::Output {
        Vec3 {
            x: self.x * other,
            y: self.y * other,
            z: self.z * other
        }
    }
}

impl Mul<Vec3> for f32 {
    type Output = Vec3;
    /// Multiplies each vector component by scalar.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let v = vec3!(1.0, 2.0, 3.0);
    /// let s = 3.0;
    ///
    /// assert_eq!(s * v, vec3!(3.0, 6.0, 9.0))
    /// ```
    fn mul(self, other: Vec3) -> Self::Output {
        Vec3 {
            x: self * other.x,
            y: self * other.y,
            z: self * other.z
        }
    }
}


impl Div<Vec3> for Vec3 {
    type Output = Vec3;
    /// Divides vector components.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(4.0, 2.0, 10.0);
    /// let b = vec3!(2.0);
    ///
    /// assert_eq!(a / b, vec3!(2.0, 1.0, 5.0));
    /// ```
    fn div(self, other: Vec3) -> Self::Output {
        Vec3 {
            x: self.x / other.x,
            y: self.y / other.y,
            z: self.z / other.z
        }
    }
}

impl Div<f32> for Vec3 {
    type Output = Vec3;
    /// Divides each vector component by scalar.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let a = vec3!(4.0, 2.0, 10.0);
    /// let s = 2.0;
    ///
    /// assert_eq!(a / s, vec3!(2.0, 1.0, 5.0));
    /// ```
    fn div(self, other: f32) -> Self::Output {
        Vec3 {
            x: self.x / other,
            y: self.y / other,
            z: self.z / other
        }
    }
}


impl AddAssign for Vec3 {
    /// Sums vector components and assigns the result to the vector on the left.
    ///
    /// Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(5.0);
    /// let b = vec3!(1.0, 2.0, 3.0);
    /// a += b;
    ///
    /// assert_eq!(a, vec3!(6.0, 7.0, 8.0));
    /// ```
    fn add_assign(&mut self, other: Vec3) {
        *self = Vec3 {
            x: self.x + other.x,
            y: self.y + other.y,
            z: self.z + other.z
        };
    }
}


impl SubAssign for Vec3 {
    /// Subtracts vector components and assigns the result to the vector on the left.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(5.0);
    /// let b = vec3!(1.0, 2.0, 3.0);
    /// a -= b;
    ///
    /// assert_eq!(a, vec3!(4.0, 3.0, 2.0));
    /// ```
    fn sub_assign(&mut self, other: Vec3) {
        *self = Vec3 {
            x: self.x - other.x,
            y: self.y - other.y,
            z: self.z - other.z
        };
    }
}


impl MulAssign<Vec3> for Vec3 {
    /// Multiplies vector components and assigns the result to the vector on the left.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(1.0, 2.0, 3.0);
    /// let b = vec3!(2.0);
    /// a *= b;
    ///
    /// assert_eq!(a, vec3!(2.0, 4.0, 6.0));
    /// ```
    fn mul_assign(&mut self, other: Vec3) {
        *self = Vec3 {
            x: self.x * other.x,
            y: self.y * other.y,
            z: self.z * other.z
        };
    }
}

impl MulAssign<f32> for Vec3 {
    /// Multiplies each vector component by scalar and assigns the result to the vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(1.0, 2.0, 3.0);
    /// let s = 2.0;
    /// a *= s;
    ///
    /// assert_eq!(a, vec3!(2.0, 4.0, 6.0));
    /// ```
    fn mul_assign(&mut self, other: f32) {
        *self = Vec3 {
            x: self.x * other,
            y: self.y * other,
            z: self.z * other
        }
    }
}


impl DivAssign<Vec3> for Vec3 {
    /// Divides vector components and assigns the result to the vector on the left.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(2.0, 4.0, 6.0);
    /// let b = vec3!(2.0);
    /// a /= b;
    ///
    /// assert_eq!(a, vec3!(1.0, 2.0, 3.0));
    /// ```
    fn div_assign(&mut self, other: Vec3) {
        *self = Vec3 {
            x: self.x / other.x,
            y: self.y / other.y,
            z: self.z / other.z
        }
    }
}

impl DivAssign<f32> for Vec3 {
    /// Divides each vector component by scalar and assigns the result to the vector.
    ///
    /// # Examples
    ///
    /// ```rust
    /// # use raytracer::vec3;
    /// let mut a = vec3!(2.0, 4.0, 6.0);
    /// let s = 2.0;
    /// a /= s;
    ///
    /// assert_eq!(a, vec3!(1.0, 2.0, 3.0));
    /// ```
    fn div_assign(&mut self, other: f32) {
        *self = Vec3 {
            x: self.x / other,
            y: self.y / other,
            z: self.z / other
        }
    }
}




/// Shorthand for [`Vec3::new`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{Vec3, vec3};
/// // fast initialization of equal fields
/// let vec = vec3!(1.0);
/// assert_eq!(vec, Vec3::new(1.0, 1.0, 1.0));
///
/// // create a Vec3 normally
/// let vec = vec3!(1.0, 2.5, 3.0);
/// assert_eq!(vec, Vec3::new(1.0, 2.5, 3.0));
/// ```
///
/// [`Vec3::new`]: vec3/struct.Vec3.html#method.new
#[macro_export]
macro_rules! vec3 {
    ($value:expr) => { $crate::Vec3::new($value, $value, $value) };
    ($x:expr, $y:expr, $z:expr) => { $crate::Vec3::new($x, $y, $z) };
}

/// Alternative for [`Vec3::dot`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, dot};
/// let a = vec3!(1.0, 2.0, 3.0);
/// let b = vec3!(1.0, 5.0, 7.0);
///
/// assert_eq!(dot!(a, b), 32.0);
/// assert_eq!(dot!(a, b), dot!(b, a));
/// ```
///
/// [`Vec3::dot`]: vec3/struct.Vec3.html#method.dot
#[macro_export]
macro_rules! dot {
    ($a:expr, $b:expr) => { $a.dot($b) }
}

/// Alternative for [`Vec3::cross`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, cross};
/// let i = vec3!(1.0, 0.0, 0.0);
/// let j = vec3!(0.0, 1.0, 0.0);
/// let k = vec3!(0.0, 0.0, 1.0);
///
/// assert_eq!(cross!(i, j), k);
/// assert_eq!(cross!(j, k), i);
/// assert_eq!(cross!(k, i), j);
///
/// assert_eq!(cross!(j, i), -k);
/// assert_eq!(cross!(k, j), -i);
/// assert_eq!(cross!(i, k), -j);
/// ```
///
/// [`Vec3::cross`]: vec3/struct.Vec3.html#method.cross
#[macro_export]
macro_rules! cross {
    ($a:expr, $b:expr) => { $a.cross($b) }
}

/// Alternative for [`Vec3::len`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, len};
/// let v = vec3!(3.0, 4.0, 0.0);
///
/// assert_eq!(len!(v), 5.0);
/// ```
///
/// [`Vec3::len`]: vec3/struct.Vec3.html#method.len
#[macro_export]
macro_rules! len {
    ($v:expr) => { $v.len() }
}

/// Alternative for [`Vec3::len_sqr`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, len_sqr};
/// let v = vec3!(3.0, 4.0, 0.0);
///
/// assert_eq!(len_sqr!(v), 25.0);
/// ```
///
/// [`Vec3::len_sqr`]: vec3/struct.Vec3.html#method.len_sqr
#[macro_export]
macro_rules! len_sqr {
    ($v:expr) => { $v.len_sqr() }
}

/// Alternative for [`Vec3::normalize`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, normalize};
/// let a = vec3!(5.0, 0.0, 0.0);
/// let b = vec3!(10.0, 0.0, 0.0);
///
/// assert_eq!(normalize!(a), normalize!(b));
/// ```
///
/// [`Vec3::normalize`]: vec3/struct.Vec3.html#method.normalize
#[macro_export]
macro_rules! normalize {
    ($v:expr) => { $v.normalize() }
}

/// Alternative for [`Vec3::reflect`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, reflect};
/// // reflective surface
/// let normal = vec3!(0.0, 1.0, 0.0);
///
/// // Reflection when ray is perpendicular
/// let incident = vec3!(0.0, -1.0, 0.0);
/// assert_eq!(reflect!(incident, normal), vec3!(0.0, 1.0, 0.0));
///
/// // Incident ray coming at 45 degree angle
/// let incident = vec3!(-1.0, -1.0, 0.0);
/// assert_eq!(reflect!(incident, normal), vec3!(-1.0, 1.0, 0.0));
/// ```
///
/// [`Vec3::reflect`]: vec3/struct.Vec3.html#method.reflect
#[macro_export]
macro_rules! reflect {
    ($v:expr, $n:expr) => { $v.reflect($n) }
}

/// Alternative for [`Vec3::refract`].
///
/// # Examples
///
/// ```rust
/// # use raytracer::{vec3, refract};
/// // Glass surface
/// let n = 1.5; // n1 / n2, where n1 = 1.5 (glass) and n2 = 1.0 (air)
/// let normal = vec3!(0.0, 1.0, 0.0);
///
/// // Rays perpendicular to the surface aren't affected by refraction
/// let incident = vec3!(0.0, -1.0, 0.0);
/// assert_eq!(refract!(incident, normal, n), Some(incident));
///
/// // Rays coming from an angle are refracted
/// let incident = vec3!(-0.7, -1.0, 0.0);
/// assert_eq!(refract!(incident, normal, n), Some(vec3!(-0.86019355, -0.5099678, 0.0)));
///
/// // At critical angles (nearing 0), rays aren't refracted, only reflected
/// let incident = vec3!(-1.0, -0.05, 0.0);
/// assert_eq!(refract!(incident, normal, n), None); // from outside of the surface
///
/// let incident = vec3!(1.0, 0.05, 0.0);
/// assert_eq!(refract!(incident, normal, n), None); // from inside of the surface
/// ```
/// [`Vec3::refract`]: vec3/struct.Vec3.html#method.refract
#[macro_export]
macro_rules! refract {
    ($v:expr, $normal:expr, $n:expr) => { $v.refract($normal, $n) }
}



#[cfg(test)]
mod tests {
    use crate::{vec3, dot, cross, len, len_sqr, normalize, reflect};
    use super::*;

    #[test]
    fn macro_vec3() {
        // first match
        let value: f32 = 2.78;
        let va1 = vec3!(value);
        let vb1 = Vec3::new(value, value, value);

        assert_eq!(va1, vb1);

        // second match
        let (x, y, z): (f32, f32, f32) = (2.98, 5.45, 6.45);
        let va3 = vec3!(x, y, z);
        let vb3 = Vec3::new(x, y, z);

        assert_eq!(va3, vb3);
    }

    #[test]
    fn macro_dot() {
        let a = vec3!(1.0, 2.0, 3.0);
        let b = vec3!(1.0, 5.0, 7.0);

        assert_eq!(dot!(a, b), 32.0);
        assert_eq!(dot!(a, b), dot!(b, a));
    }

    #[test]
    fn macro_cross() {
        let i = vec3!(1.0, 0.0, 0.0);
        let j = vec3!(0.0, 1.0, 0.0);
        let k = vec3!(0.0, 0.0, 1.0);

        assert_eq!(cross!(i, j), k);
        assert_eq!(cross!(j, k), i);
        assert_eq!(cross!(k, i), j);

        assert_eq!(cross!(j, i), -k);
        assert_eq!(cross!(k, j), -i);
        assert_eq!(cross!(i, k), -j);
    }

    #[test]
    fn macro_len() {
        let v = vec3!(3.0, 4.0, 0.0);

        assert_eq!(len!(v), 5.0);
    }

    #[test]
    fn macro_len_sqr() {
        let v = vec3!(3.0, 4.0, 0.0);

        assert_eq!(len_sqr!(v), 25.0);
    }

    #[test]
    fn macro_normalize() {
        let a = vec3!(5.0, 0.0, 0.0);
        let b = vec3!(10.0, 0.0, 0.0);

        assert_eq!(normalize!(a), normalize!(b));
    }

    #[test]
    fn macro_reflect() {
        // reflective surface
        let normal = vec3!(0.0, 1.0, 0.0);

        // Reflection when ray is perpendicular
        let incident = vec3!(0.0, -1.0, 0.0);
        assert_eq!(reflect!(incident, normal), vec3!(0.0, 1.0, 0.0));

        // Incident ray coming at 45 degree angle
        let incident = vec3!(-1.0, -1.0, 0.0);
        assert_eq!(reflect!(incident, normal), vec3!(-1.0, 1.0, 0.0));
    }

    #[test]
    fn macro_refract() {
        // Glass surface
        let n = 1.5; // n1 / n2, where n1 = 1.5 (glass) and n2 = 1.0 (air)
        let normal = vec3!(0.0, 1.0, 0.0);

        // Rays perpendicular to the surface aren't affected by refraction
        let incident = vec3!(0.0, -1.0, 0.0);
        assert_eq!(refract!(incident, normal, n), Some(incident));

        // Rays coming from an angle are refracted
        let incident = vec3!(-0.7, -1.0, 0.0);
        assert_eq!(refract!(incident, normal, n), Some(vec3!(-0.86019355, -0.5099678, 0.0)));

        // At critical angles (nearing 0), rays aren't refracted, only reflected
        let incident = vec3!(-1.0, -0.05, 0.0);
        assert_eq!(refract!(incident, normal, n), None); // from outside of the surface

        let incident = vec3!(1.0, 0.05, 0.0);
        assert_eq!(refract!(incident, normal, n), None); // from inside of the surface
    }

    #[test]
    fn vec3_new() {
        // constructor
        let v = Vec3::new(1.0, 2.0, 3.0);

        assert_eq!(v.x, 1.0);
        assert_eq!(v.y, 2.0);
        assert_eq!(v.z, 3.0);
    }

    #[test]
    fn vec3_dot() {
        let a = vec3!(1.0, 2.0, 3.0);
        let b = vec3!(1.0, 5.0, 7.0);

        assert_eq!(a.dot(b), 32.0);
        assert_eq!(a.dot(b), b.dot(a));
    }

    #[test]
    fn vec3_cross() {
        let i = vec3!(1.0, 0.0, 0.0);
        let j = vec3!(0.0, 1.0, 0.0);
        let k = vec3!(0.0, 0.0, 1.0);

        assert_eq!(i.cross(j), k);
        assert_eq!(j.cross(k), i);
        assert_eq!(k.cross(i), j);

        assert_eq!(j.cross(i), -k);
        assert_eq!(k.cross(j), -i);
        assert_eq!(i.cross(k), -j);
    }

    #[test]
    fn vec3_len() {
        let v = vec3!(3.0, 4.0, 0.0);

        assert_eq!(v.len(), 5.0);
    }

    #[test]
    fn vec3_len_sqr() {
        let v = vec3!(3.0, 4.0, 0.0);

        assert_eq!(v.len_sqr(), 25.0);
    }

    #[test]
    fn vec3_normalize() {
        let a = vec3!(5.0, 0.0, 0.0);
        let b = vec3!(10.0, 0.0, 0.0);

        assert_eq!(a.normalize(), b.normalize());
    }

    #[test]
    fn vec3_reflect() {
        // reflective surface
        let normal = vec3!(0.0, 1.0, 0.0);

        // Reflection when ray is perpendicular
        let incident = vec3!(0.0, -1.0, 0.0);
        assert_eq!(incident.reflect(normal), vec3!(0.0, 1.0, 0.0));

        // Incident ray coming at 45 degree angle
        let incident = vec3!(-1.0, -1.0, 0.0);
        assert_eq!(incident.reflect(normal), vec3!(-1.0, 1.0, 0.0));
    }

    #[test]
    fn vec3_refract() {
        // Glass surface
        let n = 1.5; // n1 / n2, where n1 = 1.5 (glass) and n2 = 1.0 (air)
        let normal = vec3!(0.0, 1.0, 0.0);

        // Rays perpendicular to the surface aren't affected by refraction
        let incident = vec3!(0.0, -1.0, 0.0);
        assert_eq!(incident.refract(normal, n), Some(incident));

        // Rays coming from an angle are refracted
        let incident = vec3!(-0.7, -1.0, 0.0);
        assert_eq!(incident.refract(normal, n), Some(vec3!(-0.86019355, -0.5099678, 0.0)));

        // At critical angles (nearing 0), rays aren't refracted, only reflected
        let incident = vec3!(-1.0, -0.05, 0.0);
        assert_eq!(incident.refract(normal, n), None); // from outside of the surface

        let incident = vec3!(1.0, 0.05, 0.0);
        assert_eq!(incident.refract(normal, n), None); // from inside of the surface
    }

    #[test]
    fn vec3_neg() {
        // -Vec3
        let a = vec3!(2.0, 5.0, 7.0);

        assert_eq!(-a, vec3!(-2.0, -5.0, -7.0));
    }

    #[test]
    fn vec3_add() {
        // Vec3 + Vec3
        let a = vec3!(2.0, 3.0, 4.0);
        let b = vec3!(1.0, 0.0, -1.0);

        assert_eq!(a + b, vec3!(3.0));
    }

    #[test]
    fn vec3_sub() {
        // Vec3 - Vec3
        let a = vec3!(5.0, 6.0, 7.0);
        let b = vec3!(2.0, 3.0, 4.0);

        assert_eq!(a - b, vec3!(3.0));
        assert_eq!(b - a, vec3!(-3.0));
    }

    #[test]
    fn vec3_mul() {
        // Vec3 * Vec3
        let a = vec3!(2.0, 3.0, 4.0);
        let b = vec3!(2.0);

        assert_eq!(a * b, vec3!(4.0, 6.0, 8.0));

        // Vec3 * f32
        let v = vec3!(2.5, 3.5, 1.0);
        let s = 2.0;
        let vs = vec3!(5.0, 7.0, 2.0);

        assert_eq!(v * s, vs);

        // f32 * Vec3
        assert_eq!(s * v, vs);
    }

    #[test]
    fn vec3_div() {
        // Vec3 / Vec3
        let a = vec3!(4.0, 6.0, 8.0);
        let b = vec3!(2.0);

        assert_eq!(a / b, vec3!(2.0, 3.0, 4.0));
        assert_eq!(b / a, vec3!(0.5, 1.0 / 3.0, 0.25));

        // Vec3 / f32
        let v = vec3!(3.0, 2.0, 4.0);
        let s = 2.0;

        assert_eq!(v / s, vec3!(1.5, 1.0, 2.0));
    }

    #[test]
    fn vec3_add_assign() {
        // Vec3 += Vec3
        let mut v = vec3!(2.0, 3.0, 5.0);
        v += vec3!(2.0, 1.0, -1.0);

        assert_eq!(v, vec3!(4.0));
    }

    #[test]
    fn vec3_sub_assign() {
        // Vec3 -= Vec3
        let mut v = vec3!(2.0, 3.0, 5.0);
        v -= vec3!(2.0, 1.0, -1.0);

        assert_eq!(v, vec3!(0.0, 2.0, 6.0));
    }

    #[test]
    fn vec3_mul_assign() {
        // Vec3 *= Vec3
        let mut v = vec3!(2.0, 4.0, 5.0);
        v *= vec3!(2.0);

        assert_eq!(v, vec3!(4.0, 8.0, 10.0));

        // Vec3 *= f32
        v *= 3.0;

        assert_eq!(v, vec3!(12.0, 24.0, 30.0));
    }

    #[test]
    fn vec3_div_assign() {
        // Vec3 /= Vec3
        let mut v = vec3!(2.0, 4.0, 6.0);
        v /= vec3!(2.0);

        assert_eq!(v, vec3!(1.0, 2.0, 3.0));

        // Vec3 /= f32
        v /= 2.0;

        assert_eq!(v, vec3!(0.5, 1.0, 1.5));
    }
}