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 scene;
mod renderer;
mod scene;
use crate::primitives::{
Vec2i,
Vec3,
};
use crate::scene::{
Camera,
Scene
};
use crate::primitives::{Vec2i, Vec3};
use crate::scene::{Camera, Scene};
use crate::renderer::{
Tile,
RenderProperties,
};
use crate::renderer::{RenderProperties, Tile};
use rand::SeedableRng;
use rand::rngs::SmallRng;
fn main() {
// image
let aspect_ratio = 3.0 / 2.0;
let image = Vec2i {
x: 400,
y: (400.0 / aspect_ratio) as i32
y: (400.0 / aspect_ratio) as i32,
};
let render_config = RenderProperties {
samples: 10,
bounces: 50
bounces: 50,
};
// random generator
@@ -48,7 +37,7 @@ fn main() {
0.1, // aperture
10.0, // dist_to_focus
),
world: Scene::random_world(&mut small_rng)
world: Scene::random_world(&mut small_rng),
};
// 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::Display;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
use rand::Rng;
use rand::rngs::SmallRng;
use rand::distr::Uniform;
use rand::rngs::SmallRng;
pub type Vec2i = Vec2<i32>;
pub type Vec2f = Vec2<f32>;
@@ -26,7 +15,6 @@ pub struct Vec2<T>{
pub y: T,
}
impl Vec2<f32> {
pub fn zero() -> Vec2<f32> {
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> {
Vec2 { x: srng.sample(distrib), y: srng.sample(distrib) }
Vec2 {
x: srng.sample(distrib),
y: srng.sample(distrib),
}
}
}
impl<T> Vec2<T>
where T: std::ops::Mul{
where
T: std::ops::Mul,
{
pub fn new(x: T, y: T) -> Vec2<T> {
Vec2 { x, y }
}
}
impl<T> Add for Vec2<T>
where T: std::ops::Add<Output = T>{
where
T: std::ops::Add<Output = T>,
{
type Output = 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>
where T: std::ops::Mul<Output = T>{
where
T: std::ops::Mul<Output = T>,
{
type Output = Vec2<T>;
fn mul(self, other: Vec2<T>) -> Vec2<T> {
Vec2 {
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> {
Vec2 {
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> {
Vec2 {
x: self.x / other,
y: self.y / other
y: self.y / other,
}
}
}
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>;
fn div(self, other: Vec2<T>) -> Vec2<T> {
Vec2 {
x: self.x / other.x,
y: self.y / other.y
y: self.y / other.y,
}
}
}
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 {
let str = format!("{} {}", self.x, self.y);
fmt.write_str(&str)
@@ -131,7 +135,7 @@ impl Vec3{
Vec3 {
x: 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();
loop {
let p = Vec3::rand(srng, distrib);
if p.length_squared() >= 1.0 { continue; }
else { return p; }
if p.length_squared() >= 1.0 {
continue;
} else {
return p;
}
}
}
@@ -160,8 +167,11 @@ impl Vec3{
y: srng.sample(distrib.unwrap()),
z: 0.0,
};
if p.length_squared() >= 1.0 { continue; }
else { return p; }
if p.length_squared() >= 1.0 {
continue;
} else {
return p;
}
}
}
@@ -179,7 +189,6 @@ impl Vec3{
// roughly equivalent to the `void write_color(...)` in the book
pub fn print_ppm(&self, samples_per_pixel: u32) -> String {
let scale = 1.0 / samples_per_pixel as f32;
// now with gamma correction
@@ -195,10 +204,7 @@ impl Vec3{
pub fn near_zero(&self) -> bool {
let epsilon: f32 = 1e-4;
return
self.x.abs() < epsilon &&
self.y.abs() < epsilon &&
self.z.abs() < epsilon
return self.x.abs() < epsilon && self.y.abs() < epsilon && self.z.abs() < epsilon;
}
pub fn reflect(v: Vec3, n: Vec3) -> Vec3 {
@@ -213,16 +219,14 @@ impl Vec3{
}
pub fn dot(left: Vec3, right: Vec3) -> f32 {
left.x * right.x +
left.y * right.y +
left.z * right.z
left.x * right.x + left.y * right.y + left.z * right.z
}
pub fn cross(u: Vec3, v: Vec3) -> Vec3 {
Vec3 {
x: u.y * v.z - u.z * v.y,
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();
v / len
}
}
impl Add for Vec3 {
type Output = Vec3;
@@ -248,7 +251,7 @@ impl AddAssign for Vec3 {
*self = Self {
x: self.x + other.x,
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 {
x: self.x - other.x,
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 {
x: self.x * other.x,
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 {
x: self.x * other,
y: self.y * other,
z: self.z * other
z: self.z * other,
};
}
}
@@ -343,7 +346,7 @@ impl DivAssign<Vec3> for Vec3 {
*self = Self {
x: self.x / other.x,
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 {
x: self.x / 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);
fmt.write_str(&str)?;
Ok(())
}
}
@@ -658,7 +660,6 @@ mod test{
let refl = Vec3::reflect(ray, normal);
let expected = Vec3::new(-1.0, 0.0, 0.0);
assert!(refl == expected);
}
#[test]
@@ -666,7 +667,6 @@ mod test{
let ray = Vec3::new(1.0, 0.0, 0.0);
let normal = Vec3::as_unit(Vec3::new(-1.0, 1.0, 0.0));
let refl = Vec3::reflect(ray, normal);
let expected = Vec3::new(0.0, 1.0, 0.0);
let diff = refl - expected;
@@ -678,12 +678,9 @@ mod test{
fn check_lerp() {
let ray = Ray {
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);
assert_eq!(
half,
Vec3::new(0.5, 0.5, 0.0)
);
assert_eq!(half, Vec3::new(0.5, 0.5, 0.0));
}
}

81
src/renderer.rs
View File

@@ -1,21 +1,15 @@
use crate::primitives::{
Vec2i,
Vec2f,
Vec3,
Ray,
Rect,
};
use crate::scene::{
Hittable,
Scene,
};
use crate::primitives::{Ray, Rect, Vec2f, Vec2i, Vec3};
use crate::scene::{Hittable, Scene};
use rand::rngs::SmallRng;
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 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)
}
fn ray_color(
r: Ray, surface: &Hittable, depth: u32,
rng: &mut SmallRng,
) -> Vec3 {
fn ray_color(r: Ray, surface: &Hittable, depth: u32, rng: &mut SmallRng) -> Vec3 {
// recursion guard
if depth == 0 {
return Vec3::zero();
@@ -44,26 +35,22 @@ fn ray_color(
dir: Vec3::zero(),
};
let mut attenuation = Vec3::zero();
if record.material.scatter(
r,
&record,
&mut attenuation,
&mut scattered,
rng
) {
return attenuation * ray_color(
scattered, surface, depth-1, rng
);
if record
.material
.scatter(r, &record, &mut attenuation, &mut scattered, rng)
{
return attenuation * ray_color(scattered, surface, depth - 1, rng);
}
} // TODO: explicit else block
// 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
// 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 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)
rng: &mut SmallRng,
) -> Vec3 {
(0..render_props.samples)
.fold(
Vec3::zero(),
|color, _sample| -> Vec3 {
(0..render_props.samples).fold(Vec3::zero(), |color, _sample| -> Vec3 {
let uv = to_uv(coord, img_size);
let ray = scene.camera.get_ray(uv.x, uv.y, rng);
if ray.dir.x.is_nan() {
panic!("Ray dir.x is NAN");
}
color + ray_color(ray, &scene.world, render_props.bounces, rng)
}
)
})
}
pub struct Tile {
@@ -102,22 +85,25 @@ impl Tile {
properties: &RenderProperties, // TODO: Place image size in render properties?
rng: &mut SmallRng,
) -> Self {
let pixel_iter = (bounds.y..(bounds.y + bounds.h))
.cartesian_product( bounds.x..(bounds.x + bounds.w));
let pixels = pixel_iter.map(
|coord| -> Vec3 {
let pixel_iter =
(bounds.y..(bounds.y + bounds.h)).cartesian_product(bounds.x..(bounds.x + bounds.w));
let pixels = pixel_iter
.map(|coord| -> Vec3 {
sample_pixel(
Vec2i{x: coord.1, y: coord.0},
Vec2i {
x: coord.1,
y: coord.0,
},
scene,
properties,
img_size,
rng,
)
}
).collect();
})
.collect();
Self {
_bounds: bounds,
pixels
pixels,
}
}
pub fn render_line(
@@ -128,11 +114,16 @@ impl Tile {
rng: &mut SmallRng, // rng utils
) -> Self {
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,
scene,
properties,
rng
rng,
)
}
}

145
src/scene.rs
View File

@@ -1,9 +1,8 @@
use crate::primitives::{Vec3, Ray};
use crate::primitives::{Ray, Vec3};
use rand::Rng;
use rand::rngs::SmallRng;
use rand::distr::Uniform;
use rand::rngs::SmallRng;
pub struct HitRecord {
pub p: Vec3,
@@ -16,32 +15,45 @@ pub struct HitRecord{
impl HitRecord {
pub fn set_face_normal(&mut self, r: Ray, outward_normal: Vec3) -> () {
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)]
pub enum Hittable {
Sphere { center: Vec3, radius: f32, material: Material },
HittableList { hittables: Vec<Hittable> }
Sphere {
center: Vec3,
radius: f32,
material: Material,
},
HittableList {
hittables: Vec<Hittable>,
},
}
impl Hittable {
pub fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> {
match self {
Hittable::HittableList { hittables } => {
hittables.iter()
.map( |obj| -> Option<HitRecord> {
obj.hit(r, t_min, t_max)
}).filter(|obj| obj.is_some())
Hittable::HittableList { hittables } => hittables
.iter()
.map(|obj| -> Option<HitRecord> { obj.hit(r, t_min, t_max) })
.filter(|obj| obj.is_some())
.min_by(|lhs, rhs| {
let lhs = lhs.as_ref().unwrap();
let rhs = rhs.as_ref().unwrap();
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 a = r.dir.length_squared();
let half_b = Vec3::dot(oc, r.dir);
@@ -81,7 +93,6 @@ impl Hittable {
}
}
#[derive(Copy, Clone, Debug)]
pub enum Material {
Lambertian { albedo: Vec3 },
@@ -103,7 +114,8 @@ impl Material {
let scatter_dir = rec.normal + Vec3::rand_unit_vector(srng);
// 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.
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
} else {
scatter_dir // else preserve current
@@ -114,26 +126,27 @@ impl Material {
// using them at all)
*scattered = Ray {
orig: rec.p,
dir: scatter_dir
dir: scatter_dir,
};
*attenuation = *albedo; // deref on both sides? Wacky
return true;
},
}
Material::Metal { albedo, fuzz } => {
let reflected = Vec3::reflect(
Vec3::as_unit(ray_in.dir),
rec.normal
);
let reflected = Vec3::reflect(Vec3::as_unit(ray_in.dir), rec.normal);
*scattered = Ray {
orig: rec.p,
dir: reflected + Vec3::rand_in_unit_sphere(srng) * *fuzz,
};
*attenuation = *albedo;
return Vec3::dot(scattered.dir, rec.normal) > 0.0;
},
}
Material::Dielectric { index_refraction } => {
*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 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 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)
} else {
Vec3::refract(unit_direction, rec.normal, refraction_ratio)
};
*scattered = Ray {
orig: rec.p,
dir: direction
dir: direction,
};
return true;
},
}
}
}
@@ -174,7 +190,8 @@ pub struct Camera {
lower_left_corner: Vec3,
horizontal: Vec3,
vertical: Vec3,
u: Vec3, v: Vec3, /*w: Vec3,*/
u: Vec3,
v: Vec3, /*w: Vec3,*/
lens_radius: f32,
}
@@ -186,7 +203,7 @@ impl Camera {
vfov: f32,
aspect_ratio: f32,
aperture: f32,
focus_dist: f32
focus_dist: f32,
) -> Camera {
let theta = degrees_to_radians(vfov);
let h = (theta / 2.0).tan();
@@ -207,7 +224,8 @@ impl Camera {
lower_left_corner,
horizontal: horiz,
vertical: verti,
u, v, /* w,*/
u,
v, /* w,*/
lens_radius: aperture / 2.0,
}
}
@@ -216,10 +234,8 @@ impl Camera {
let rd = Vec3::rand_in_unit_disk(srng) * self.lens_radius;
let offset = self.u * rd.x + self.v * rd.y;
let dir = self.lower_left_corner
+ self.horizontal * s
+ self.vertical * t
- self.origin - offset;
let dir =
self.lower_left_corner + self.horizontal * s + self.vertical * t - self.origin - offset;
Ray {
orig: self.origin + offset,
dir,
@@ -227,7 +243,6 @@ impl Camera {
}
}
pub struct Scene {
pub camera: Camera,
pub world: Hittable,
@@ -235,10 +250,18 @@ pub struct Scene {
impl Scene {
pub fn random_world(srng: &mut SmallRng) -> Hittable {
let mat_ground = Material::Lambertian { albedo: Vec3::new(0.5, 0.5, 0.5) };
let mut world = Hittable::HittableList { hittables : Vec::<Hittable>::new() };
let mat_ground = Material::Lambertian {
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();
for a in -11..11 {
@@ -250,18 +273,16 @@ impl Scene {
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 choose_mat < 0.8 {
// 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 };
world.push(
Hittable::Sphere {
world.push(Hittable::Sphere {
center,
radius: 0.2,
material: sphere_material,
}
);
});
} else if choose_mat < 0.95 {
// metal
let distr_albedo = Uniform::new(0.5, 1.0).unwrap();
@@ -270,48 +291,52 @@ impl Scene {
let albedo = Vec3::rand(srng, distr_albedo);
let fuzz = srng.sample(distr_fuzz);
let material = Material::Metal { albedo, fuzz };
world.push(
Hittable::Sphere {
world.push(Hittable::Sphere {
center,
radius: 0.2,
material: material,
}
);
});
} else {
// glass
let material = Material::Dielectric { index_refraction: 1.5 };
world.push(
Hittable::Sphere{
let material = Material::Dielectric {
index_refraction: 1.5,
};
world.push(Hittable::Sphere {
center,
radius: 0.2,
material: material,
}
);
});
};
}
}
}
let material1 = Material::Dielectric { index_refraction: 1.5 };
let material1 = Material::Dielectric {
index_refraction: 1.5,
};
world.push(Hittable::Sphere {
center: Vec3::new(0.0, 1.0, 0.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 {
center: Vec3::new(-4.0, 1.0, 0.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 {
center: Vec3::new(4.0, 1.0, 0.0),
radius: 1.0,
material: material3
material: material3,
});
world
}