robert/rustpt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

autoformat the project

Browse Source
This commit is contained in:
Robert Garrett
2025-08-19 18:21:51 -05:00
parent 05add1efca
commit 34a828fe67
4 changed files with 431 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/main.rs
View File

@@ -1,37 +1,26 @@
mod primitives; mod primitives;
mod scene;
mod renderer; mod renderer;
mod scene;
use crate::primitives::{ use crate::primitives::{Vec2i, Vec3};
Vec2i, use crate::scene::{Camera, Scene};
Vec3,
};
use crate::scene::{
Camera,
Scene
};
use crate::renderer::{ use crate::renderer::{RenderProperties, Tile};
Tile,
RenderProperties,
};
use rand::SeedableRng; use rand::SeedableRng;
use rand::rngs::SmallRng; use rand::rngs::SmallRng;
fn main() { fn main() {
// image // image
let aspect_ratio = 3.0 / 2.0; let aspect_ratio = 3.0 / 2.0;
let image = Vec2i { let image = Vec2i {
x: 400, x: 400,
y: (400.0 / aspect_ratio) as i32 y: (400.0 / aspect_ratio) as i32,
}; };
let render_config = RenderProperties { let render_config = RenderProperties {
samples: 10, samples: 10,
bounces: 50 bounces: 50,
}; };
// random generator // random generator
@@ -48,7 +37,7 @@ fn main() {
0.1, // aperture 0.1, // aperture
10.0, // dist_to_focus 10.0, // dist_to_focus
), ),
world: Scene::random_world(&mut small_rng) world: Scene::random_world(&mut small_rng),
}; };
// render // render

107
src/primitives.rs
View File

@@ -1,21 +1,10 @@
use std::ops::{
Add,
AddAssign,
Sub,
SubAssign,
Mul,
MulAssign,
Div,
DivAssign,
Neg,
};
use std::fmt; use std::fmt;
use std::fmt::Display; use std::fmt::Display;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
use rand::Rng; use rand::Rng;
use rand::rngs::SmallRng;
use rand::distr::Uniform; use rand::distr::Uniform;
use rand::rngs::SmallRng;
pub type Vec2i = Vec2<i32>; pub type Vec2i = Vec2<i32>;
pub type Vec2f = Vec2<f32>; pub type Vec2f = Vec2<f32>;
@@ -26,7 +15,6 @@ pub struct Vec2<T>{
pub y: T, pub y: T,
} }
impl Vec2<f32> { impl Vec2<f32> {
pub fn zero() -> Vec2<f32> { pub fn zero() -> Vec2<f32> {
Vec2 { x: 0.0, y: 0.0 } Vec2 { x: 0.0, y: 0.0 }
@@ -37,33 +25,44 @@ impl Vec2<f32> {
} }
pub fn rand(srng: &mut SmallRng, distrib: Uniform<f32>) -> Vec2<f32> { pub fn rand(srng: &mut SmallRng, distrib: Uniform<f32>) -> Vec2<f32> {
Vec2 { x: srng.sample(distrib), y: srng.sample(distrib) } Vec2 {
x: srng.sample(distrib),
y: srng.sample(distrib),
}
} }
} }
impl<T> Vec2<T> impl<T> Vec2<T>
where T: std::ops::Mul{ where
T: std::ops::Mul,
{
pub fn new(x: T, y: T) -> Vec2<T> { pub fn new(x: T, y: T) -> Vec2<T> {
Vec2 { x, y } Vec2 { x, y }
} }
} }
impl<T> Add for Vec2<T> impl<T> Add for Vec2<T>
where T: std::ops::Add<Output = T>{ where
T: std::ops::Add<Output = T>,
{
type Output = Vec2<T>; type Output = Vec2<T>;
fn add(self, other: Vec2<T>) -> Vec2<T> { fn add(self, other: Vec2<T>) -> Vec2<T> {
Vec2 { x: self.x + other.x, y: self.y + other.y } Vec2 {
x: self.x + other.x,
y: self.y + other.y,
}
} }
} }
impl<T> Mul for Vec2<T> impl<T> Mul for Vec2<T>
where T: std::ops::Mul<Output = T>{ where
T: std::ops::Mul<Output = T>,
{
type Output = Vec2<T>; type Output = Vec2<T>;
fn mul(self, other: Vec2<T>) -> Vec2<T> { fn mul(self, other: Vec2<T>) -> Vec2<T> {
Vec2 { Vec2 {
x: self.x * other.x, x: self.x * other.x,
y: self.y * other.y y: self.y * other.y,
} }
} }
} }
@@ -73,7 +72,7 @@ impl Div<f32> for Vec2<f32>{
fn div(self, other: f32) -> Vec2<f32> { fn div(self, other: f32) -> Vec2<f32> {
Vec2 { Vec2 {
x: 1.0 / other * self.x, x: 1.0 / other * self.x,
y: 1.0/other * self.y y: 1.0 / other * self.y,
} }
} }
} }
@@ -83,24 +82,29 @@ impl Div<i32> for Vec2<i32>{
fn div(self, other: i32) -> Vec2<i32> { fn div(self, other: i32) -> Vec2<i32> {
Vec2 { Vec2 {
x: self.x / other, x: self.x / other,
y: self.y / other y: self.y / other,
} }
} }
} }
impl<T> Div<Vec2<T>> for Vec2<T> impl<T> Div<Vec2<T>> for Vec2<T>
where T: std::ops::Div<Output = T>{ where
T: std::ops::Div<Output = T>,
{
type Output = Vec2<T>; type Output = Vec2<T>;
fn div(self, other: Vec2<T>) -> Vec2<T> { fn div(self, other: Vec2<T>) -> Vec2<T> {
Vec2 { Vec2 {
x: self.x / other.x, x: self.x / other.x,
y: self.y / other.y y: self.y / other.y,
} }
} }
} }
impl<T> Display for Vec2<T> impl<T> Display for Vec2<T>
where T: Display { // nested type still needs to have Display where
T: Display,
{
// nested type still needs to have Display
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let str = format!("{} {}", self.x, self.y); let str = format!("{} {}", self.x, self.y);
fmt.write_str(&str) fmt.write_str(&str)
@@ -131,7 +135,7 @@ impl Vec3{
Vec3 { Vec3 {
x: 1.0, x: 1.0,
y: 1.0, y: 1.0,
z: 1.0 z: 1.0,
} }
} }
@@ -147,8 +151,11 @@ impl Vec3{
let distrib = Uniform::new(-1.0, 1.0).unwrap(); let distrib = Uniform::new(-1.0, 1.0).unwrap();
loop { loop {
let p = Vec3::rand(srng, distrib); let p = Vec3::rand(srng, distrib);
if p.length_squared() >= 1.0 { continue; } if p.length_squared() >= 1.0 {
else { return p; } continue;
} else {
return p;
}
} }
} }
@@ -160,8 +167,11 @@ impl Vec3{
y: srng.sample(distrib.unwrap()), y: srng.sample(distrib.unwrap()),
z: 0.0, z: 0.0,
}; };
if p.length_squared() >= 1.0 { continue; } if p.length_squared() >= 1.0 {
else { return p; } continue;
} else {
return p;
}
} }
} }
@@ -179,7 +189,6 @@ impl Vec3{
// roughly equivalent to the `void write_color(...)` in the book // roughly equivalent to the `void write_color(...)` in the book
pub fn print_ppm(&self, samples_per_pixel: u32) -> String { pub fn print_ppm(&self, samples_per_pixel: u32) -> String {
let scale = 1.0 / samples_per_pixel as f32; let scale = 1.0 / samples_per_pixel as f32;
// now with gamma correction // now with gamma correction
@@ -195,10 +204,7 @@ impl Vec3{
pub fn near_zero(&self) -> bool { pub fn near_zero(&self) -> bool {
let epsilon: f32 = 1e-4; let epsilon: f32 = 1e-4;
return return self.x.abs() < epsilon && self.y.abs() < epsilon && self.z.abs() < epsilon;
self.x.abs() < epsilon &&
self.y.abs() < epsilon &&
self.z.abs() < epsilon
} }
pub fn reflect(v: Vec3, n: Vec3) -> Vec3 { pub fn reflect(v: Vec3, n: Vec3) -> Vec3 {
@@ -213,16 +219,14 @@ impl Vec3{
} }
pub fn dot(left: Vec3, right: Vec3) -> f32 { pub fn dot(left: Vec3, right: Vec3) -> f32 {
left.x * right.x + left.x * right.x + left.y * right.y + left.z * right.z
left.y * right.y +
left.z * right.z
} }
pub fn cross(u: Vec3, v: Vec3) -> Vec3 { pub fn cross(u: Vec3, v: Vec3) -> Vec3 {
Vec3 { Vec3 {
x: u.y * v.z - u.z * v.y, x: u.y * v.z - u.z * v.y,
y: u.z * v.x - u.x * v.z, y: u.z * v.x - u.x * v.z,
z: u.x * v.y - u.y * v.x z: u.x * v.y - u.y * v.x,
} }
} }
@@ -230,7 +234,6 @@ impl Vec3{
let len = v.length(); let len = v.length();
v / len v / len
} }
} }
impl Add for Vec3 { impl Add for Vec3 {
type Output = Vec3; type Output = Vec3;
@@ -248,7 +251,7 @@ impl AddAssign for Vec3 {
*self = Self { *self = Self {
x: self.x + other.x, x: self.x + other.x,
y: self.y + other.y, y: self.y + other.y,
z: self.z + other.z z: self.z + other.z,
}; };
} }
} }
@@ -269,7 +272,7 @@ impl SubAssign for Vec3 {
*self = Self { *self = Self {
x: self.x - other.x, x: self.x - other.x,
y: self.y - other.y, y: self.y - other.y,
z: self.z - other.z z: self.z - other.z,
}; };
} }
} }
@@ -301,7 +304,7 @@ impl MulAssign<Vec3> for Vec3 {
*self = Self { *self = Self {
x: self.x * other.x, x: self.x * other.x,
y: self.y * other.y, y: self.y * other.y,
z: self.z * other.z z: self.z * other.z,
}; };
} }
} }
@@ -311,7 +314,7 @@ impl MulAssign<f32> for Vec3{
*self = Self { *self = Self {
x: self.x * other, x: self.x * other,
y: self.y * other, y: self.y * other,
z: self.z * other z: self.z * other,
}; };
} }
} }
@@ -343,7 +346,7 @@ impl DivAssign<Vec3> for Vec3 {
*self = Self { *self = Self {
x: self.x / other.x, x: self.x / other.x,
y: self.y / other.y, y: self.y / other.y,
z: self.z / other.z z: self.z / other.z,
}; };
} }
} }
@@ -353,7 +356,7 @@ impl DivAssign<f32> for Vec3 {
*self = Self { *self = Self {
x: self.x / other, x: self.x / other,
y: self.y / other, y: self.y / other,
z: self.z / other z: self.z / other,
}; };
} }
} }
@@ -374,7 +377,6 @@ impl Display for Vec3 {
let str = format!("{} {} {}", self.x, self.y, self.z); let str = format!("{} {} {}", self.x, self.y, self.z);
fmt.write_str(&str)?; fmt.write_str(&str)?;
Ok(()) Ok(())
} }
} }
@@ -658,7 +660,6 @@ mod test{
let refl = Vec3::reflect(ray, normal); let refl = Vec3::reflect(ray, normal);
let expected = Vec3::new(-1.0, 0.0, 0.0); let expected = Vec3::new(-1.0, 0.0, 0.0);
assert!(refl == expected); assert!(refl == expected);
} }
#[test] #[test]
@@ -666,7 +667,6 @@ mod test{
let ray = Vec3::new(1.0, 0.0, 0.0); let ray = Vec3::new(1.0, 0.0, 0.0);
let normal = Vec3::as_unit(Vec3::new(-1.0, 1.0, 0.0)); let normal = Vec3::as_unit(Vec3::new(-1.0, 1.0, 0.0));
let refl = Vec3::reflect(ray, normal); let refl = Vec3::reflect(ray, normal);
let expected = Vec3::new(0.0, 1.0, 0.0); let expected = Vec3::new(0.0, 1.0, 0.0);
let diff = refl - expected; let diff = refl - expected;
@@ -678,12 +678,9 @@ mod test{
fn check_lerp() { fn check_lerp() {
let ray = Ray { let ray = Ray {
orig: Vec3::new(0.0, 0.0, 0.0), orig: Vec3::new(0.0, 0.0, 0.0),
dir: Vec3::new(1.0, 1.0, 0.0) dir: Vec3::new(1.0, 1.0, 0.0),
}; };
let half = ray.at(0.5); let half = ray.at(0.5);
assert_eq!( assert_eq!(half, Vec3::new(0.5, 0.5, 0.0));
half,
Vec3::new(0.5, 0.5, 0.0)
);
} }
} }

81
src/renderer.rs
View File

@@ -1,21 +1,15 @@
use crate::primitives::{Ray, Rect, Vec2f, Vec2i, Vec3};
use crate::primitives::{ use crate::scene::{Hittable, Scene};
Vec2i,
Vec2f,
Vec3,
Ray,
Rect,
};
use crate::scene::{
Hittable,
Scene,
};
use rand::rngs::SmallRng; use rand::rngs::SmallRng;
use itertools::{self, Itertools}; use itertools::{self, Itertools};
const SKY_COLOR: Vec3 = Vec3 { x: 0.5, y: 0.7, z: 1.0}; const SKY_COLOR: Vec3 = Vec3 {
x: 0.5,
y: 0.7,
z: 1.0,
};
pub struct RenderProperties { pub struct RenderProperties {
pub samples: u32, // samples are averaged results over a pixel pub samples: u32, // samples are averaged results over a pixel
@@ -28,10 +22,7 @@ fn to_uv(coord: Vec2i, img_size: Vec2i) -> Vec2f {
Vec2f::new(u, v) Vec2f::new(u, v)
} }
fn ray_color( fn ray_color(r: Ray, surface: &Hittable, depth: u32, rng: &mut SmallRng) -> Vec3 {
r: Ray, surface: &Hittable, depth: u32,
rng: &mut SmallRng,
) -> Vec3 {
// recursion guard // recursion guard
if depth == 0 { if depth == 0 {
return Vec3::zero(); return Vec3::zero();
@@ -44,26 +35,22 @@ fn ray_color(
dir: Vec3::zero(), dir: Vec3::zero(),
}; };
let mut attenuation = Vec3::zero(); let mut attenuation = Vec3::zero();
if record.material.scatter( if record
r, .material
&record, .scatter(r, &record, &mut attenuation, &mut scattered, rng)
&mut attenuation, {
&mut scattered, return attenuation * ray_color(scattered, surface, depth - 1, rng);
rng
) {
return attenuation * ray_color(
scattered, surface, depth-1, rng
);
} }
} // TODO: explicit else block } // TODO: explicit else block
// Rust gets angry about the inner if{} block because it evaluates to () // Rust gets angry about the inner if{} block because it evaluates to ()
// when the else path is taken. This is a problem for a function // when the else path is taken. This is a problem for a function
// that returns Vec3 and not (). // that returns Vec3 and not ().
{ // when nothing is struck, return sky color {
// when nothing is struck, return sky color
let unitdir = Vec3::as_unit(r.dir); let unitdir = Vec3::as_unit(r.dir);
let t = 0.5 * (unitdir.y + 1.0); let t = 0.5 * (unitdir.y + 1.0);
return Vec3::ones() * (1.0 - t) + SKY_COLOR * t return Vec3::ones() * (1.0 - t) + SKY_COLOR * t;
} }
} }
@@ -75,18 +62,14 @@ fn sample_pixel(
// Supplied by the execution environment (the thread) // Supplied by the execution environment (the thread)
rng: &mut SmallRng, rng: &mut SmallRng,
) -> Vec3 { ) -> Vec3 {
(0..render_props.samples) (0..render_props.samples).fold(Vec3::zero(), |color, _sample| -> Vec3 {
.fold(
Vec3::zero(),
|color, _sample| -> Vec3 {
let uv = to_uv(coord, img_size); let uv = to_uv(coord, img_size);
let ray = scene.camera.get_ray(uv.x, uv.y, rng); let ray = scene.camera.get_ray(uv.x, uv.y, rng);
if ray.dir.x.is_nan() { if ray.dir.x.is_nan() {
panic!("Ray dir.x is NAN"); panic!("Ray dir.x is NAN");
} }
color + ray_color(ray, &scene.world, render_props.bounces, rng) color + ray_color(ray, &scene.world, render_props.bounces, rng)
} })
)
} }
pub struct Tile { pub struct Tile {
@@ -102,22 +85,25 @@ impl Tile {
properties: &RenderProperties, // TODO: Place image size in render properties? properties: &RenderProperties, // TODO: Place image size in render properties?
rng: &mut SmallRng, rng: &mut SmallRng,
) -> Self { ) -> Self {
let pixel_iter = (bounds.y..(bounds.y + bounds.h)) let pixel_iter =
.cartesian_product( bounds.x..(bounds.x + bounds.w)); (bounds.y..(bounds.y + bounds.h)).cartesian_product(bounds.x..(bounds.x + bounds.w));
let pixels = pixel_iter.map( let pixels = pixel_iter
|coord| -> Vec3 { .map(|coord| -> Vec3 {
sample_pixel( sample_pixel(
Vec2i{x: coord.1, y: coord.0}, Vec2i {
x: coord.1,
y: coord.0,
},
scene, scene,
properties, properties,
img_size, img_size,
rng, rng,
) )
} })
).collect(); .collect();
Self { Self {
_bounds: bounds, _bounds: bounds,
pixels pixels,
} }
} }
pub fn render_line( pub fn render_line(
@@ -128,11 +114,16 @@ impl Tile {
rng: &mut SmallRng, // rng utils rng: &mut SmallRng, // rng utils
) -> Self { ) -> Self {
Tile::render_tile( Tile::render_tile(
Rect{ x: 0, y, w: img_size.x, h: 1 }, Rect {
x: 0,
y,
w: img_size.x,
h: 1,
},
img_size, img_size,
scene, scene,
properties, properties,
rng rng,
) )
} }
} }

145
src/scene.rs
View File

@@ -1,9 +1,8 @@
use crate::primitives::{Ray, Vec3};
use crate::primitives::{Vec3, Ray};
use rand::Rng; use rand::Rng;
use rand::rngs::SmallRng;
use rand::distr::Uniform; use rand::distr::Uniform;
use rand::rngs::SmallRng;
pub struct HitRecord { pub struct HitRecord {
pub p: Vec3, pub p: Vec3,
@@ -16,32 +15,45 @@ pub struct HitRecord{
impl HitRecord { impl HitRecord {
pub fn set_face_normal(&mut self, r: Ray, outward_normal: Vec3) -> () { pub fn set_face_normal(&mut self, r: Ray, outward_normal: Vec3) -> () {
self.front_face = Vec3::dot(r.dir, outward_normal) < 0.0; self.front_face = Vec3::dot(r.dir, outward_normal) < 0.0;
self.normal = if self.front_face { outward_normal } else { -outward_normal }; self.normal = if self.front_face {
outward_normal
} else {
-outward_normal
};
} }
} }
#[derive(Clone)] #[derive(Clone)]
pub enum Hittable { pub enum Hittable {
Sphere { center: Vec3, radius: f32, material: Material }, Sphere {
HittableList { hittables: Vec<Hittable> } center: Vec3,
radius: f32,
material: Material,
},
HittableList {
hittables: Vec<Hittable>,
},
} }
impl Hittable { impl Hittable {
pub fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> { pub fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> {
match self { match self {
Hittable::HittableList { hittables } => { Hittable::HittableList { hittables } => hittables
hittables.iter() .iter()
.map( |obj| -> Option<HitRecord> { .map(|obj| -> Option<HitRecord> { obj.hit(r, t_min, t_max) })
obj.hit(r, t_min, t_max) .filter(|obj| obj.is_some())
}).filter(|obj| obj.is_some())
.min_by(|lhs, rhs| { .min_by(|lhs, rhs| {
let lhs = lhs.as_ref().unwrap(); let lhs = lhs.as_ref().unwrap();
let rhs = rhs.as_ref().unwrap(); let rhs = rhs.as_ref().unwrap();
lhs.t.partial_cmp(&rhs.t).expect("Couldn't compare??") lhs.t.partial_cmp(&rhs.t).expect("Couldn't compare??")
}).unwrap_or(None) })
} .unwrap_or(None),
Hittable::Sphere { center, radius, material } => { Hittable::Sphere {
center,
radius,
material,
} => {
let oc = r.orig - *center; let oc = r.orig - *center;
let a = r.dir.length_squared(); let a = r.dir.length_squared();
let half_b = Vec3::dot(oc, r.dir); let half_b = Vec3::dot(oc, r.dir);
@@ -81,7 +93,6 @@ impl Hittable {
} }
} }
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
pub enum Material { pub enum Material {
Lambertian { albedo: Vec3 }, Lambertian { albedo: Vec3 },
@@ -103,7 +114,8 @@ impl Material {
let scatter_dir = rec.normal + Vec3::rand_unit_vector(srng); let scatter_dir = rec.normal + Vec3::rand_unit_vector(srng);
// The compiler might be smart enough to compute this ^^^ just once. In which case, // The compiler might be smart enough to compute this ^^^ just once. In which case,
// I don't need to do this weird dance. Oh well. It'll work. // I don't need to do this weird dance. Oh well. It'll work.
let scatter_dir = if scatter_dir.near_zero() { // if near zero, let scatter_dir = if scatter_dir.near_zero() {
// if near zero,
rec.normal // replace with normal rec.normal // replace with normal
} else { } else {
scatter_dir // else preserve current scatter_dir // else preserve current
@@ -114,26 +126,27 @@ impl Material {
// using them at all) // using them at all)
*scattered = Ray { *scattered = Ray {
orig: rec.p, orig: rec.p,
dir: scatter_dir dir: scatter_dir,
}; };
*attenuation = *albedo; // deref on both sides? Wacky *attenuation = *albedo; // deref on both sides? Wacky
return true; return true;
}, }
Material::Metal { albedo, fuzz } => { Material::Metal { albedo, fuzz } => {
let reflected = Vec3::reflect( let reflected = Vec3::reflect(Vec3::as_unit(ray_in.dir), rec.normal);
Vec3::as_unit(ray_in.dir),
rec.normal
);
*scattered = Ray { *scattered = Ray {
orig: rec.p, orig: rec.p,
dir: reflected + Vec3::rand_in_unit_sphere(srng) * *fuzz, dir: reflected + Vec3::rand_in_unit_sphere(srng) * *fuzz,
}; };
*attenuation = *albedo; *attenuation = *albedo;
return Vec3::dot(scattered.dir, rec.normal) > 0.0; return Vec3::dot(scattered.dir, rec.normal) > 0.0;
}, }
Material::Dielectric { index_refraction } => { Material::Dielectric { index_refraction } => {
*attenuation = Vec3::ones(); *attenuation = Vec3::ones();
let refraction_ratio = if rec.front_face { 1.0 / index_refraction } else { *index_refraction }; let refraction_ratio = if rec.front_face {
1.0 / index_refraction
} else {
*index_refraction
};
let unit_direction = Vec3::as_unit(ray_in.dir); let unit_direction = Vec3::as_unit(ray_in.dir);
let cos_theta = Vec3::dot(-unit_direction, rec.normal).min(1.0); let cos_theta = Vec3::dot(-unit_direction, rec.normal).min(1.0);
@@ -141,17 +154,20 @@ impl Material {
let cannot_refract = refraction_ratio * sin_theta > 1.0; let cannot_refract = refraction_ratio * sin_theta > 1.0;
let distrib_zero_one = Uniform::new(0.0, 1.0).unwrap(); let distrib_zero_one = Uniform::new(0.0, 1.0).unwrap();
let direction = if cannot_refract || Material::reflectance(cos_theta, refraction_ratio) > srng.sample(distrib_zero_one) { let direction = if cannot_refract
|| Material::reflectance(cos_theta, refraction_ratio)
> srng.sample(distrib_zero_one)
{
Vec3::reflect(unit_direction, rec.normal) Vec3::reflect(unit_direction, rec.normal)
} else { } else {
Vec3::refract(unit_direction, rec.normal, refraction_ratio) Vec3::refract(unit_direction, rec.normal, refraction_ratio)
}; };
*scattered = Ray { *scattered = Ray {
orig: rec.p, orig: rec.p,
dir: direction dir: direction,
}; };
return true; return true;
}, }
} }
} }
@@ -174,7 +190,8 @@ pub struct Camera {
lower_left_corner: Vec3, lower_left_corner: Vec3,
horizontal: Vec3, horizontal: Vec3,
vertical: Vec3, vertical: Vec3,
u: Vec3, v: Vec3, /*w: Vec3,*/ u: Vec3,
v: Vec3, /*w: Vec3,*/
lens_radius: f32, lens_radius: f32,
} }
@@ -186,7 +203,7 @@ impl Camera {
vfov: f32, vfov: f32,
aspect_ratio: f32, aspect_ratio: f32,
aperture: f32, aperture: f32,
focus_dist: f32 focus_dist: f32,
) -> Camera { ) -> Camera {
let theta = degrees_to_radians(vfov); let theta = degrees_to_radians(vfov);
let h = (theta / 2.0).tan(); let h = (theta / 2.0).tan();
@@ -207,7 +224,8 @@ impl Camera {
lower_left_corner, lower_left_corner,
horizontal: horiz, horizontal: horiz,
vertical: verti, vertical: verti,
u, v, /* w,*/ u,
v, /* w,*/
lens_radius: aperture / 2.0, lens_radius: aperture / 2.0,
} }
} }
@@ -216,10 +234,8 @@ impl Camera {
let rd = Vec3::rand_in_unit_disk(srng) * self.lens_radius; let rd = Vec3::rand_in_unit_disk(srng) * self.lens_radius;
let offset = self.u * rd.x + self.v * rd.y; let offset = self.u * rd.x + self.v * rd.y;
let dir = self.lower_left_corner let dir =
+ self.horizontal * s self.lower_left_corner + self.horizontal * s + self.vertical * t - self.origin - offset;
+ self.vertical * t
- self.origin - offset;
Ray { Ray {
orig: self.origin + offset, orig: self.origin + offset,
dir, dir,
@@ -227,7 +243,6 @@ impl Camera {
} }
} }
pub struct Scene { pub struct Scene {
pub camera: Camera, pub camera: Camera,
pub world: Hittable, pub world: Hittable,
@@ -235,10 +250,18 @@ pub struct Scene {
impl Scene { impl Scene {
pub fn random_world(srng: &mut SmallRng) -> Hittable { pub fn random_world(srng: &mut SmallRng) -> Hittable {
let mat_ground = Material::Lambertian { albedo: Vec3::new(0.5, 0.5, 0.5) }; let mat_ground = Material::Lambertian {
let mut world = Hittable::HittableList { hittables : Vec::<Hittable>::new() }; albedo: Vec3::new(0.5, 0.5, 0.5),
};
let mut world = Hittable::HittableList {
hittables: Vec::<Hittable>::new(),
};
world.push( Hittable::Sphere { center: Vec3::new(0.0, -1000.0, 0.0), radius: 1000.0, material: mat_ground }); world.push(Hittable::Sphere {
center: Vec3::new(0.0, -1000.0, 0.0),
radius: 1000.0,
material: mat_ground,
});
let distrib_zero_one = Uniform::new(0.0, 1.0).unwrap(); let distrib_zero_one = Uniform::new(0.0, 1.0).unwrap();
for a in -11..11 { for a in -11..11 {
@@ -250,18 +273,16 @@ impl Scene {
z: b as f32 + 0.9 * srng.sample(distrib_zero_one), z: b as f32 + 0.9 * srng.sample(distrib_zero_one),
}; };
if (center - Vec3::new(4.0, 0.2, 0.0)).length() > 0.9 { if (center - Vec3::new(4.0, 0.2, 0.0)).length() > 0.9 {
if choose_mat < 0.8 { if choose_mat < 0.8 {
// diffuse // diffuse
let albedo = Vec3::rand(srng, distrib_zero_one) * Vec3::rand(srng, distrib_zero_one); let albedo =
Vec3::rand(srng, distrib_zero_one) * Vec3::rand(srng, distrib_zero_one);
let sphere_material = Material::Lambertian { albedo }; let sphere_material = Material::Lambertian { albedo };
world.push( world.push(Hittable::Sphere {
Hittable::Sphere {
center, center,
radius: 0.2, radius: 0.2,
material: sphere_material, material: sphere_material,
} });
);
} else if choose_mat < 0.95 { } else if choose_mat < 0.95 {
// metal // metal
let distr_albedo = Uniform::new(0.5, 1.0).unwrap(); let distr_albedo = Uniform::new(0.5, 1.0).unwrap();
@@ -270,48 +291,52 @@ impl Scene {
let albedo = Vec3::rand(srng, distr_albedo); let albedo = Vec3::rand(srng, distr_albedo);
let fuzz = srng.sample(distr_fuzz); let fuzz = srng.sample(distr_fuzz);
let material = Material::Metal { albedo, fuzz }; let material = Material::Metal { albedo, fuzz };
world.push( world.push(Hittable::Sphere {
Hittable::Sphere {
center, center,
radius: 0.2, radius: 0.2,
material: material, material: material,
} });
);
} else { } else {
// glass // glass
let material = Material::Dielectric { index_refraction: 1.5 }; let material = Material::Dielectric {
world.push( index_refraction: 1.5,
Hittable::Sphere{ };
world.push(Hittable::Sphere {
center, center,
radius: 0.2, radius: 0.2,
material: material, material: material,
} });
);
}; };
} }
} }
} }
let material1 = Material::Dielectric { index_refraction: 1.5 }; let material1 = Material::Dielectric {
index_refraction: 1.5,
};
world.push(Hittable::Sphere { world.push(Hittable::Sphere {
center: Vec3::new(0.0, 1.0, 0.0), center: Vec3::new(0.0, 1.0, 0.0),
radius: 1.0, radius: 1.0,
material: material1 material: material1,
}); });
let material2 = Material::Lambertian { albedo: Vec3::new(0.4, 0.2, 0.1) }; let material2 = Material::Lambertian {
albedo: Vec3::new(0.4, 0.2, 0.1),
};
world.push(Hittable::Sphere { world.push(Hittable::Sphere {
center: Vec3::new(-4.0, 1.0, 0.0), center: Vec3::new(-4.0, 1.0, 0.0),
radius: 1.0, radius: 1.0,
material: material2 material: material2,
}); });
let material3 = Material::Metal { albedo: Vec3::new(0.7, 0.6, 0.5), fuzz: 0.0 }; let material3 = Material::Metal {
albedo: Vec3::new(0.7, 0.6, 0.5),
fuzz: 0.0,
};
world.push(Hittable::Sphere { world.push(Hittable::Sphere {
center: Vec3::new(4.0, 1.0, 0.0), center: Vec3::new(4.0, 1.0, 0.0),
radius: 1.0, radius: 1.0,
material: material3 material: material3,
}); });
world world
} }