96 lines
2.4 KiB
Rust
96 lines
2.4 KiB
Rust
extern crate nalgebra as na;
|
|
|
|
use std::ops::{Add, Mul};
|
|
|
|
use na::*;
|
|
use na::geometry::Point3;
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct Ray {
|
|
pub origin: Point3<f32>,
|
|
pub direction: Unit<Vector3<f32>>
|
|
}
|
|
|
|
impl Ray {
|
|
pub fn from_parts(origin: Point3<f32>, direction: Unit<Vector3<f32>>) -> Self {
|
|
Ray {
|
|
origin: origin,
|
|
direction: direction
|
|
}
|
|
}
|
|
pub fn new(origin: Point3<f32>, direction: Vector3<f32>) -> Self { Ray::from_parts(origin, Unit::new_normalize(direction)) }
|
|
pub fn from_points(origin: Point3<f32>, points_to: Point3<f32>) -> Self { Ray::new(origin, points_to - origin) }
|
|
|
|
pub fn project(&self, t: f32) -> Point3<f32> { self.origin + t * self.direction.into_inner() }
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct Color {
|
|
pub red: f32,
|
|
pub green: f32,
|
|
pub blue: f32,
|
|
|
|
_private: () // Private field prevents direct construction
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
impl Color {
|
|
pub fn new(red: f32, green: f32, blue: f32) -> Self {
|
|
Color {
|
|
red: if red < 0.0 { 0.0 } else { red },
|
|
green: if green < 0.0 { 0.0 } else { green },
|
|
blue: if blue < 0.0 { 0.0 } else { blue },
|
|
|
|
_private: ()
|
|
}
|
|
}
|
|
|
|
pub fn to_byte_array(&self) -> [u8; 3] {
|
|
let red = (255.0 * self.red) as u8;
|
|
let green = (255.0 * self.green) as u8;
|
|
let blue = (255.0 * self.blue) as u8;
|
|
[red, green, blue]
|
|
}
|
|
|
|
pub fn gray(brightness: f32) -> Self { Color::new(brightness, brightness, brightness) }
|
|
|
|
pub fn black() -> Self { Color::gray(0.0) }
|
|
pub fn white() -> Self { Color::gray(1.0) }
|
|
}
|
|
|
|
impl Add for Color {
|
|
type Output = Color;
|
|
fn add(self, rhs: Color) -> Color {
|
|
Color {
|
|
red: self.red + rhs.red,
|
|
green: self.green + rhs.green,
|
|
blue: self.blue + rhs.blue,
|
|
_private: ()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Mul for Color {
|
|
type Output = Color;
|
|
fn mul(self, rhs: Color) -> Color {
|
|
Color {
|
|
red: self.red * rhs.red,
|
|
green: self.green * rhs.green,
|
|
blue: self.blue * rhs.blue,
|
|
_private: ()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Mul<f32> for Color {
|
|
type Output = Color;
|
|
fn mul(self, rhs: f32) -> Color {
|
|
Color {
|
|
red: self.red * rhs,
|
|
green: self.green * rhs,
|
|
blue: self.blue * rhs,
|
|
_private: ()
|
|
}
|
|
}
|
|
}
|