>(&self, path: Option) -> std::io::Result<()> {
166 | // because picture height/width is always positive and small enough in practice
167 | #[allow(
168 | clippy::cast_sign_loss,
169 | clippy::cast_precision_loss,
170 | clippy::cast_possible_truncation
171 | )]
172 | Painter::new(
173 | (self.picture_height as f64 * self.camera.aspect_ratio).round() as usize,
174 | self.picture_height,
175 | )
176 | .gamma(self.gamma)
177 | .samples(self.samples)
178 | .threads(self.threads)
179 | .parallel(self.parallel)
180 | .draw(&path, |u, v| -> Vec3 {
181 | let ray = self.camera.ray(u, v);
182 | Self::ray_color(&ray, &self.world, self.depth)
183 | })
184 | }
185 | }
186 |
187 | #[derive(Debug)]
188 | pub struct CameraBuilder {
189 | look_from: Point3,
190 | look_at: Point3,
191 | vup: Vec3,
192 | fov: f64,
193 | aspect_ratio: f64,
194 | aperture: f64,
195 | focus_distance: f64,
196 | shutter_speed: f64,
197 | }
198 |
199 | impl Default for CameraBuilder {
200 | fn default() -> Self {
201 | Self {
202 | look_from: Point3::default(),
203 | look_at: Point3::new(0.0, 0.0, -1.0),
204 | vup: Vec3::new(0.0, 1.0, 0.0),
205 | fov: 90.0,
206 | aspect_ratio: 16.0 / 9.0,
207 | aperture: 0.0,
208 | focus_distance: 1.0,
209 | shutter_speed: 0.0,
210 | }
211 | }
212 | }
213 |
214 | impl CameraBuilder {
215 | #[must_use]
216 | pub const fn look_from(mut self, look_from: Point3) -> Self {
217 | self.look_from = look_from;
218 | self
219 | }
220 |
221 | #[must_use]
222 | pub const fn look_at(mut self, look_at: Point3) -> Self {
223 | self.look_at = look_at;
224 | self
225 | }
226 |
227 | #[must_use]
228 | pub const fn vup(mut self, vup: Vec3) -> Self {
229 | self.vup = vup;
230 | self
231 | }
232 |
233 | #[must_use]
234 | pub fn fov(mut self, fov: f64) -> Self {
235 | debug_assert!(0.0 < fov && fov <= 180.0, "fov = {}", fov);
236 | self.fov = fov;
237 | self
238 | }
239 |
240 | #[must_use]
241 | pub fn aspect_ratio(mut self, aspect_ratio: f64) -> Self {
242 | debug_assert!(aspect_ratio > 0.0, "aspect_ratio = {}", aspect_ratio);
243 | self.aspect_ratio = aspect_ratio;
244 | self
245 | }
246 |
247 | #[must_use]
248 | pub fn aperture(mut self, aperture: f64) -> Self {
249 | debug_assert!(aperture >= 0.0, "aperture = {}", aperture);
250 | self.aperture = aperture;
251 | self
252 | }
253 |
254 | #[must_use]
255 | pub fn focus(mut self, distance: f64) -> Self {
256 | debug_assert!(distance >= 0.0, "distance = {}", distance);
257 | self.focus_distance = distance;
258 | self
259 | }
260 |
261 | #[must_use]
262 | pub fn focus_to_look_at(self) -> Self {
263 | let distance = (&self.look_at - &self.look_from).length();
264 | self.focus(distance)
265 | }
266 |
267 | #[must_use]
268 | pub fn shutter_speed(mut self, duration: f64) -> Self {
269 | debug_assert!(duration >= 0.0, "duration = {}", duration);
270 | self.shutter_speed = duration;
271 | self
272 | }
273 |
274 | #[must_use]
275 | pub fn build(self) -> Camera {
276 | Camera::new(
277 | &self.look_from,
278 | &self.look_at,
279 | &self.vup,
280 | self.fov,
281 | self.aspect_ratio,
282 | self.aperture,
283 | self.focus_distance,
284 | self.shutter_speed,
285 | )
286 | }
287 | }
288 |
--------------------------------------------------------------------------------
/src/hittable/collection/bvh.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{collection::HittableList, HitRecord, Hittable},
4 | prelude::*,
5 | },
6 | std::{
7 | cmp::Ordering,
8 | fmt::{Debug, Formatter},
9 | ops::Range,
10 | },
11 | };
12 |
13 | #[derive(Default)]
14 | pub struct BVH {
15 | bbox: Option,
16 | left: Option>,
17 | right: Option>,
18 | }
19 |
20 | impl Debug for BVH {
21 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
22 | f.write_fmt(format_args!("BVH {{ bbox: {:?} }}", self.bbox))
23 | }
24 | }
25 |
26 | fn cmp_geometry_by(axis: usize, a: &dyn Hittable, b: &dyn Hittable) -> Ordering {
27 | let box_a = a
28 | .bbox(0.0..0.0)
29 | .expect("No bounding box in bvh_node constructor");
30 | let box_b = b
31 | .bbox(0.0..0.0)
32 | .expect("No bounding box in bvh_node constructor");
33 |
34 | box_a.min()[axis]
35 | .partial_cmp(&box_b.min()[axis])
36 | .expect("Bounding box contains NaN")
37 | }
38 |
39 | impl BVH {
40 | #[must_use]
41 | pub fn new(objects: HittableList, time_limit: Range) -> Self {
42 | let objects = objects.into_objects();
43 | if objects.is_empty() {
44 | Self::default()
45 | } else {
46 | let mut objects: Vec<_> = objects.into_iter().map(Some).collect();
47 | let count = objects.len();
48 | Self::new_internal(&mut objects, 0..count, time_limit)
49 | }
50 | }
51 |
52 | fn new_internal(
53 | objects: &mut Vec>>, index: Range, time_limit: Range,
54 | ) -> Self {
55 | let count = index.end - index.start;
56 |
57 | if count == 1 {
58 | let left = objects[index.start].take().unwrap();
59 | let bbox = left
60 | .bbox(time_limit)
61 | .expect("No bounding box in bvh_node constructor.");
62 | Self {
63 | bbox: Some(bbox),
64 | left: Some(left),
65 | right: None,
66 | }
67 | } else if count == 2 {
68 | let left = objects[index.start].take().unwrap();
69 | let right = objects[index.start + 1].take().unwrap();
70 | let left_bbox = left
71 | .bbox(time_limit.clone())
72 | .expect("No bounding box in bvh_node constructor.");
73 | let right_bbox = right
74 | .bbox(time_limit)
75 | .expect("No bounding box in bvh_node constructor.");
76 | Self {
77 | bbox: Some(left_bbox | right_bbox),
78 | left: Some(left),
79 | right: Some(right),
80 | }
81 | } else {
82 | let axis = *Random::choose(&[0, 1, 2]);
83 | objects[index.clone()].sort_by(|a, b| {
84 | cmp_geometry_by(
85 | axis,
86 | a.as_ref().unwrap().as_ref(),
87 | b.as_ref().unwrap().as_ref(),
88 | )
89 | });
90 | let mid = index.start + count / 2;
91 | let left = Box::new(Self::new_internal(
92 | objects,
93 | index.start..mid,
94 | time_limit.clone(),
95 | ));
96 | let right = Box::new(Self::new_internal(objects, mid..index.end, time_limit));
97 | Self {
98 | bbox: Some(left.bbox.as_ref().unwrap() | right.bbox.as_ref().unwrap()),
99 | left: Some(left),
100 | right: Some(right),
101 | }
102 | }
103 | }
104 | }
105 |
106 | /// Bounding Volume Hierarchies
107 | impl Hittable for BVH {
108 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option> {
109 | let bbox = self.bbox.as_ref()?;
110 | if !bbox.hit(ray, unit_limit.clone()) {
111 | return None;
112 | }
113 |
114 | let hit_left = self
115 | .left
116 | .as_ref()
117 | .and_then(|left| left.hit(ray, unit_limit.clone()));
118 | let hit_right = self.right.as_ref().and_then(|right| {
119 | let right_limit = unit_limit.start
120 | ..hit_left
121 | .as_ref()
122 | .map_or(unit_limit.end, |record| record.unit);
123 | right.hit(ray, right_limit)
124 | });
125 |
126 | // Right has small t then left if it return `Some`, so right appear first
127 | hit_right.or(hit_left)
128 | }
129 |
130 | fn bbox(&self, _time_limit: Range) -> Option {
131 | self.bbox.clone()
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/src/hittable/collection/list.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{Hittable, HitRecord},
4 | prelude::*,
5 | },
6 | std::{
7 | fmt::{Debug, Formatter},
8 | ops::Range,
9 | },
10 | };
11 |
12 | #[derive(Default)]
13 | pub struct HittableList {
14 | objects: Vec>,
15 | }
16 |
17 | impl Debug for HittableList {
18 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
19 | f.write_fmt(format_args!(
20 | "GeometryList {{ objects: {}}}",
21 | self.objects.len()
22 | ))
23 | }
24 | }
25 |
26 | impl HittableList {
27 | pub fn add(&mut self, object: G) -> &mut Self {
28 | let object: Box = Box::new(object);
29 | self.objects.push(object);
30 | self
31 | }
32 |
33 | pub fn add_ref(&mut self, object: Box) -> &mut Self {
34 | self.objects.push(object);
35 | self
36 | }
37 |
38 | pub fn clear(&mut self) {
39 | self.objects.clear();
40 | }
41 |
42 | #[must_use]
43 | pub fn into_objects(self) -> Vec> {
44 | self.objects
45 | }
46 | }
47 |
48 | impl Hittable for HittableList {
49 | fn hit(&self, r: &Ray, unit_limit: Range) -> Option> {
50 | self.objects
51 | .iter()
52 | .filter_map(|object| object.hit(r, unit_limit.clone()))
53 | .min_by(|r1, r2| r1.unit.partial_cmp(&r2.unit).unwrap())
54 | }
55 |
56 | fn bbox(&self, time_limit: Range) -> Option {
57 | if self.objects.is_empty() {
58 | return None;
59 | }
60 |
61 | let mut result: Option = None;
62 |
63 | for object in &self.objects {
64 | let bbox = object.bbox(time_limit.clone())?;
65 | result = result.map(|last| last | &bbox).or(Some(bbox))
66 | }
67 |
68 | result
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/src/hittable/collection/mod.rs:
--------------------------------------------------------------------------------
1 | pub(crate) mod bvh;
2 | pub(crate) mod list;
3 | pub(crate) mod world;
4 |
5 | pub use {
6 | bvh::BVH,
7 | list::HittableList,
8 | world::{default_background as world_default_background, World},
9 | };
10 |
--------------------------------------------------------------------------------
/src/hittable/collection/world.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{
4 | collection::{HittableList, BVH},
5 | HitRecord, Hittable,
6 | },
7 | prelude::*,
8 | },
9 | std::{
10 | fmt::{Debug, Formatter},
11 | ops::Range,
12 | },
13 | };
14 |
15 | #[must_use]
16 | pub fn default_background(ray: &Ray) -> Color {
17 | let unit = ray.direction.unit();
18 | let t = 0.5 * (unit.y + 1.0);
19 | Color::new(1.0, 1.0, 1.0).gradient(&Color::new(0.5, 0.7, 1.0), t)
20 | }
21 |
22 | pub struct World {
23 | bvh: BVH,
24 | bg_func: Box Color + Send + Sync>,
25 | }
26 |
27 | impl Debug for World {
28 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
29 | f.write_str("World {}")
30 | }
31 | }
32 |
33 | impl World {
34 | #[must_use]
35 | pub fn new(list: HittableList, time_range: Range) -> Self {
36 | Self {
37 | bvh: BVH::new(list, time_range),
38 | bg_func: Box::new(default_background),
39 | }
40 | }
41 |
42 | pub fn set_bg(&mut self, f: F)
43 | where
44 | F: Fn(&Ray) -> Color + Send + Sync + 'static,
45 | {
46 | self.bg_func = Box::new(f);
47 | }
48 |
49 | #[must_use]
50 | pub fn background(&self, ray: &Ray) -> Color {
51 | let f = &self.bg_func;
52 | f(ray)
53 | }
54 | }
55 |
56 | impl Hittable for World {
57 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option> {
58 | self.bvh.hit(ray, unit_limit)
59 | }
60 |
61 | fn bbox(&self, time_limit: Range) -> Option {
62 | self.bvh.bbox(time_limit)
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/hittable/geometry/carton.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{collection::HittableList, AARect, AARectMetrics, Hittable, HitRecord},
4 | material::Material,
5 | prelude::*,
6 | },
7 | std::{ops::Range, sync::Arc},
8 | };
9 |
10 | #[derive(Debug)]
11 | pub struct Carton {
12 | point_min: Point3,
13 | point_max: Point3,
14 | material: Arc,
15 | faces: HittableList,
16 | }
17 |
18 | impl Clone for Carton {
19 | fn clone(&self) -> Self {
20 | Self::new_inner(
21 | self.point_min.clone(),
22 | self.point_max.clone(),
23 | Arc::clone(&self.material),
24 | )
25 | }
26 | }
27 |
28 | impl Carton {
29 | #[allow(clippy::needless_pass_by_value)] // for api consistency
30 | pub fn new(p0: Point3, p1: Point3, material: M) -> Self {
31 | let point_min = Point3::new_min(&p0, &p1);
32 | let point_max = Point3::new_max(&p0, &p1);
33 | let shared_material = Arc::new(material);
34 | Self::new_inner(point_min, point_max, shared_material)
35 | }
36 |
37 | #[allow(clippy::too_many_lines)]
38 | fn new_inner(point_min: Point3, point_max: Point3, material: Arc) -> Self {
39 | let mut faces = HittableList::default();
40 | faces
41 | .add(AARect::new_xy(
42 | // back
43 | AARectMetrics::new(
44 | point_min.z,
45 | (point_min.x, point_max.x),
46 | (point_min.y, point_max.y),
47 | ),
48 | Arc::clone(&material),
49 | ))
50 | .add(AARect::new_xy(
51 | // front
52 | AARectMetrics::new(
53 | point_max.z,
54 | (point_min.x, point_max.x),
55 | (point_min.y, point_max.y),
56 | ),
57 | Arc::clone(&material),
58 | ))
59 | .add(AARect::new_yz(
60 | // left
61 | AARectMetrics::new(
62 | point_min.x,
63 | (point_min.y, point_max.y),
64 | (point_min.z, point_max.z),
65 | ),
66 | Arc::clone(&material),
67 | ))
68 | .add(AARect::new_yz(
69 | // right
70 | AARectMetrics::new(
71 | point_max.x,
72 | (point_min.y, point_max.y),
73 | (point_min.z, point_max.z),
74 | ),
75 | Arc::clone(&material),
76 | ))
77 | .add(AARect::new_xz(
78 | // down
79 | AARectMetrics::new(
80 | point_min.y,
81 | (point_min.x, point_max.x),
82 | (point_min.z, point_max.z),
83 | ),
84 | Arc::clone(&material),
85 | ))
86 | .add(AARect::new_xz(
87 | // up
88 | AARectMetrics::new(
89 | point_max.y,
90 | (point_min.x, point_max.x),
91 | (point_min.z, point_max.z),
92 | ),
93 | Arc::clone(&material),
94 | ));
95 |
96 | Self {
97 | point_min,
98 | point_max,
99 | material,
100 | faces,
101 | }
102 | }
103 | }
104 |
105 | impl Hittable for Carton {
106 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option> {
107 | self.faces.hit(ray, unit_limit)
108 | }
109 |
110 | fn bbox(&self, time_limit: Range) -> Option {
111 | self.faces.bbox(time_limit)
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/src/hittable/geometry/mod.rs:
--------------------------------------------------------------------------------
1 | pub(crate) mod carton;
2 | pub(crate) mod rect;
3 | pub(crate) mod sphere;
4 |
5 | pub use {
6 | carton::Carton,
7 | rect::{AARect, AARectMetrics},
8 | sphere::Sphere,
9 | };
10 |
--------------------------------------------------------------------------------
/src/hittable/geometry/rect.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{Hittable, HitRecord},
4 | material::Material,
5 | prelude::*,
6 | },
7 | std::ops::Range,
8 | };
9 |
10 | #[derive(Debug, Clone)]
11 | pub struct AARectMetrics {
12 | k: f64,
13 | a0: f64,
14 | a1: f64,
15 | b0: f64,
16 | b1: f64,
17 | a_len: f64,
18 | b_len: f64,
19 | }
20 |
21 | impl AARectMetrics {
22 | #[must_use]
23 | pub fn new(k: f64, (a0, a1): (f64, f64), (b0, b1): (f64, f64)) -> Self {
24 | assert!(a0 < a1);
25 | assert!(b0 < b1);
26 | Self {
27 | k,
28 | a0,
29 | a1,
30 | b0,
31 | b1,
32 | a_len: a1 - a0,
33 | b_len: b1 - b0,
34 | }
35 | }
36 | }
37 |
38 | #[derive(Debug, Clone)]
39 | pub struct AARect {
40 | // 0: a axis, 1: b axis, 2: fixed axis
41 | axis: (usize, usize, usize),
42 | metrics: AARectMetrics,
43 | material: M,
44 | }
45 |
46 | impl AARect {
47 | pub const fn new_xy(metrics: AARectMetrics, material: M) -> Self {
48 | Self {
49 | metrics,
50 | material,
51 | axis: (0, 1, 2),
52 | }
53 | }
54 |
55 | pub const fn new_xz(metrics: AARectMetrics, material: M) -> Self {
56 | Self {
57 | metrics,
58 | material,
59 | axis: (0, 2, 1),
60 | }
61 | }
62 |
63 | pub const fn new_yz(metrics: AARectMetrics, material: M) -> Self {
64 | Self {
65 | metrics,
66 | material,
67 | axis: (1, 2, 0),
68 | }
69 | }
70 | }
71 |
72 | impl Hittable for AARect {
73 | fn normal(&self, _point: &Point3) -> Vec3 {
74 | let mut n = Vec3::default();
75 | n[self.axis.2] = 1.0;
76 | n
77 | }
78 |
79 | fn material(&self) -> &dyn Material {
80 | &self.material
81 | }
82 |
83 | fn uv(&self, point: &Point3) -> (f64, f64) {
84 | (
85 | (point[self.axis.0] - self.metrics.a0) / self.metrics.a_len,
86 | (point[self.axis.1] - self.metrics.b0) / self.metrics.b_len,
87 | )
88 | }
89 |
90 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option> {
91 | let unit = (self.metrics.k - ray.origin[self.axis.2]) / ray.direction[self.axis.2];
92 | if !unit_limit.contains(&unit) {
93 | return None;
94 | }
95 |
96 | let a = unit.mul_add(ray.direction[self.axis.0], ray.origin[self.axis.0]);
97 |
98 | if a < self.metrics.a0 || a > self.metrics.a1 {
99 | return None;
100 | }
101 |
102 | let b = unit.mul_add(ray.direction[self.axis.1], ray.origin[self.axis.1]);
103 |
104 | if b < self.metrics.b0 || b > self.metrics.b1 {
105 | return None;
106 | }
107 |
108 | Some(HitRecord::new(ray, self, unit))
109 | }
110 |
111 | fn bbox(&self, _time_limit: Range) -> Option {
112 | let mut p0 = Point3::default();
113 | p0[self.axis.0] = self.metrics.a0;
114 | p0[self.axis.1] = self.metrics.b0;
115 | p0[self.axis.2] = self.metrics.k - 0.0001;
116 |
117 | let mut p1 = Point3::default();
118 | p1[self.axis.0] = self.metrics.a1;
119 | p1[self.axis.1] = self.metrics.b1;
120 | p1[self.axis.2] = self.metrics.k + 0.0001;
121 |
122 | Some(AABB::new(p0, p1))
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/src/hittable/geometry/sphere.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{HitRecord, Hittable},
4 | material::Material,
5 | prelude::*,
6 | },
7 | std::{
8 | fmt::{Debug, Formatter},
9 | ops::Range,
10 | },
11 | };
12 |
13 | #[derive(Clone)]
14 | pub struct Sphere {
15 | center: Point3,
16 | radius: f64,
17 | speed: Vec3,
18 | material: M,
19 | radius_squared: f64,
20 | }
21 |
22 | impl Debug for Sphere {
23 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
24 | f.write_fmt(format_args!(
25 | "Sphere {{ center: {:?}, radius: {}, speed: {:?} }}",
26 | self.center, self.radius, self.speed,
27 | ))
28 | }
29 | }
30 |
31 | impl Sphere {
32 | pub fn new(center: Point3, radius: f64, material: M) -> Self {
33 | Self {
34 | center,
35 | radius,
36 | material,
37 | speed: Vec3::default(),
38 | radius_squared: radius * radius,
39 | }
40 | }
41 |
42 | pub const fn with_speed(mut self, speed: Vec3) -> Self {
43 | self.speed = speed;
44 | self
45 | }
46 |
47 | pub fn center_at(&self, t: f64) -> Point3 {
48 | &self.center + &self.speed * t
49 | }
50 | }
51 |
52 | impl Hittable for Sphere {
53 | fn normal(&self, point: &Point3) -> crate::prelude::Vec3 {
54 | (point - &self.center) / self.radius
55 | }
56 |
57 | fn material(&self) -> &dyn Material {
58 | &self.material
59 | }
60 |
61 | fn uv(&self, point: &Point3) -> (f64, f64) {
62 | let point = (point - &self.center).unit();
63 | let phi = (-point.z).atan2(point.x); // [-pi, pi]
64 | let theta = point.y.asin(); // [-pi / 2 , pi / 2]
65 | let u = phi / 2.0 / PI + 0.5;
66 | let v = theta / PI + 0.5;
67 | (u, v)
68 | }
69 |
70 | // Ray(t) = O + tD
71 | // Sphere surface = (X - C)^2 = r^2
72 | // (O + tD - C)^2 = r^2
73 | // let O - C = L
74 | // (tD + L)^2 = r^2
75 | // D^2 t^2 + 2DLt + L^2- r^2 = 0
76 | // a = D^2, b = 2(DL), c = L^2 - r^2
77 | // Delta = b^2 - 4ac = 4(DL)^2 - 4 D^2 (L^2 - r2)
78 | // So, check (DL)^2 - D^2(L^2 - r^2)
79 | // root is
80 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option> {
81 | let current_center = self.center_at(ray.departure_time);
82 | let l = &ray.origin - current_center;
83 | let half_b = ray.direction.dot(&l);
84 | let a = ray.direction.length_squared();
85 | let c = l.length_squared() - self.radius_squared;
86 | #[allow(clippy::suspicious_operation_groupings)]
87 | let delta = half_b * half_b - a * c;
88 |
89 | if delta < 0.0 {
90 | return None;
91 | }
92 |
93 | let sqrt = delta.sqrt();
94 |
95 | let t1 = (-half_b - sqrt) / a;
96 | if unit_limit.contains(&t1) {
97 | return Some(HitRecord::new(ray, self, t1));
98 | }
99 |
100 | let t2 = (-half_b + sqrt) / a;
101 | if unit_limit.contains(&t2) {
102 | return Some(HitRecord::new(ray, self, t2));
103 | }
104 |
105 | None
106 | }
107 |
108 | fn bbox(&self, time_limit: Range) -> Option {
109 | Some(
110 | if self.speed.x == 0.0 && self.speed.y == 0.0 && self.speed.z == 0.0 {
111 | AABB::new(
112 | &self.center - Vec3::new(self.radius, self.radius, self.radius),
113 | &self.center + Vec3::new(self.radius, self.radius, self.radius),
114 | )
115 | } else {
116 | let start = AABB::new(
117 | self.center_at(time_limit.start)
118 | - Vec3::new(self.radius, self.radius, self.radius),
119 | self.center_at(time_limit.start)
120 | + Vec3::new(self.radius, self.radius, self.radius),
121 | );
122 |
123 | let end = AABB::new(
124 | self.center_at(time_limit.end)
125 | - Vec3::new(self.radius, self.radius, self.radius),
126 | self.center_at(time_limit.end)
127 | + Vec3::new(self.radius, self.radius, self.radius),
128 | );
129 |
130 | start | end
131 | },
132 | )
133 | }
134 | }
135 |
--------------------------------------------------------------------------------
/src/hittable/hit.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{material::Material, prelude::*},
3 | std::{
4 | fmt::{Debug, Formatter},
5 | ops::Range,
6 | },
7 | };
8 |
9 | pub struct HitRecord<'m> {
10 | pub point: Point3,
11 | pub normal: Vec3,
12 | pub material: &'m dyn Material,
13 | pub unit: f64,
14 | pub u: f64,
15 | pub v: f64,
16 | pub outside: bool,
17 | }
18 |
19 | impl Debug for HitRecord<'_> {
20 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
21 | f.write_fmt(format_args!(
22 | "HitRecord {{ unit: {}, hit: {:?}, normal: {:?}, outside: {} }}",
23 | self.unit, self.point, self.normal, self.outside
24 | ))
25 | }
26 | }
27 |
28 | impl<'m> HitRecord<'m> {
29 | pub fn new(r: &Ray, object: &'m G, unit: f64) -> Self {
30 | let point = r.position_after(unit);
31 | let mut normal = object.normal(&point);
32 | let outside = r.direction.dot(&normal) < 0.0;
33 | if !outside {
34 | normal.reverse();
35 | }
36 | let material = object.material();
37 | let (u, v) = object.uv(&point);
38 | Self {
39 | point,
40 | normal,
41 | material,
42 | unit,
43 | u,
44 | v,
45 | outside,
46 | }
47 | }
48 | }
49 |
50 | #[allow(unused_variables)]
51 | pub trait Hittable: Send + Sync {
52 | fn normal(&self, point: &Point3) -> Vec3 {
53 | unimplemented!(
54 | "{}'s normal function should not be called directly",
55 | std::any::type_name::()
56 | )
57 | }
58 | fn material(&self) -> &dyn Material {
59 | unimplemented!(
60 | "{}'s material function should not be called directly",
61 | std::any::type_name::()
62 | )
63 | }
64 | fn uv(&self, point: &Point3) -> (f64, f64) {
65 | unimplemented!(
66 | "{}'s uv function should not be called directly",
67 | std::any::type_name::()
68 | )
69 | }
70 | fn hit(&self, ray: &Ray, unit_limit: Range) -> Option>;
71 | fn bbox(&self, time_limit: Range) -> Option;
72 | }
73 |
--------------------------------------------------------------------------------
/src/hittable/medium/constant.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | hittable::{HitRecord, Hittable},
3 | material::Isotropic,
4 | prelude::*,
5 | };
6 |
7 | #[derive(Debug)]
8 | pub struct ConstantMedium {
9 | boundary: T,
10 | material: Isotropic,
11 | density: f64,
12 | neg_inv_density: f64,
13 | }
14 |
15 | impl ConstantMedium {
16 | #[must_use]
17 | pub fn new(boundary: T, color: Color, density: f64) -> Self {
18 | Self {
19 | boundary,
20 | material: Isotropic::new(color),
21 | density,
22 | neg_inv_density: -1.0 / density,
23 | }
24 | }
25 | }
26 |
27 | impl Hittable for ConstantMedium {
28 | fn hit(
29 | &self, ray: &Ray, unit_limit: std::ops::Range,
30 | ) -> Option> {
31 | let mut rec1 = self.boundary.hit(ray, f64::NEG_INFINITY..f64::INFINITY)?;
32 | let mut rec2 = self.boundary.hit(ray, rec1.unit + 0.0001..f64::INFINITY)?;
33 | if rec1.unit < unit_limit.start {
34 | rec1.unit = unit_limit.start;
35 | }
36 | if rec2.unit > unit_limit.end {
37 | rec2.unit = unit_limit.end;
38 | }
39 | if rec1.unit >= rec2.unit {
40 | return None;
41 | }
42 | if rec1.unit < 0.0 {
43 | rec1.unit = 0.0;
44 | }
45 |
46 | let length_per_unit = ray.direction.length();
47 | let distance_inside = (rec2.unit - rec1.unit) * length_per_unit;
48 | let hit_distance = self.neg_inv_density * Random::normal().ln();
49 |
50 | if hit_distance > distance_inside {
51 | return None;
52 | }
53 |
54 | let hit_point_unit = rec1.unit + hit_distance / length_per_unit;
55 |
56 | Some(HitRecord {
57 | point: ray.position_after(hit_point_unit),
58 | normal: Vec3::new(1.0, 0.0, 0.0), // useless,
59 | material: &self.material,
60 | unit: hit_point_unit,
61 | u: 0.0, // useless
62 | v: 0.0, // useless
63 | outside: false, // useless
64 | })
65 | }
66 |
67 | fn bbox(&self, time_limit: std::ops::Range) -> Option {
68 | self.boundary.bbox(time_limit)
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/src/hittable/medium/mod.rs:
--------------------------------------------------------------------------------
1 | pub(crate) mod constant;
2 |
3 | pub use constant::ConstantMedium;
4 |
--------------------------------------------------------------------------------
/src/hittable/mod.rs:
--------------------------------------------------------------------------------
1 | pub(crate) mod hit;
2 |
3 | pub mod collection;
4 | pub mod geometry;
5 | pub mod medium;
6 | pub mod transform;
7 |
8 | pub use {
9 | geometry::{AARect, AARectMetrics, Carton, Sphere},
10 | hit::{HitRecord, Hittable},
11 | };
12 |
--------------------------------------------------------------------------------
/src/hittable/transform/mod.rs:
--------------------------------------------------------------------------------
1 | pub(crate) mod rotation;
2 | pub(crate) mod translation;
3 |
4 | pub use {
5 | rotation::{AARotation, ByXAxis, ByYAxis, ByZAxis},
6 | translation::Translation,
7 | };
8 |
--------------------------------------------------------------------------------
/src/hittable/transform/rotation.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::{HitRecord, Hittable},
4 | prelude::*,
5 | },
6 | once_cell::sync::OnceCell,
7 | std::marker::PhantomData,
8 | };
9 |
10 | pub trait RotationByAxis: Send + Sync {
11 | fn rotate(point: &Point3, radian: f64) -> Point3;
12 | }
13 |
14 | #[derive(Debug)]
15 | pub struct ByXAxis;
16 |
17 | impl RotationByAxis for ByXAxis {
18 | fn rotate(point: &Point3, radian: f64) -> Point3 {
19 | Point3::new(
20 | point.x,
21 | radian.cos() * point.y - radian.sin() * point.z,
22 | radian.sin().mul_add(point.y, radian.cos() * point.z),
23 | )
24 | }
25 | }
26 |
27 | #[derive(Debug)]
28 | pub struct ByYAxis;
29 |
30 | impl RotationByAxis for ByYAxis {
31 | fn rotate(point: &Point3, radian: f64) -> Point3 {
32 | Point3::new(
33 | radian.cos().mul_add(point.x, radian.sin() * point.z),
34 | point.y,
35 | (-radian.sin()).mul_add(point.x, radian.cos() * point.z),
36 | )
37 | }
38 | }
39 |
40 | #[derive(Debug)]
41 | pub struct ByZAxis;
42 |
43 | impl RotationByAxis for ByZAxis {
44 | fn rotate(point: &Point3, radian: f64) -> Point3 {
45 | Point3::new(
46 | radian.cos() * point.x - radian.sin() * point.y,
47 | radian.sin().mul_add(point.x, radian.cos() * point.y),
48 | point.z,
49 | )
50 | }
51 | }
52 |
53 | #[derive(Debug)]
54 | pub struct AARotation {
55 | object: T,
56 | radian: f64,
57 | bbox_cache: OnceCell>,
58 | axes: PhantomData,
59 | }
60 |
61 | impl AARotation {
62 | pub fn new(object: T, angle: f64) -> Self {
63 | Self {
64 | object,
65 | radian: angle.to_radians(),
66 | bbox_cache: OnceCell::new(),
67 | axes: PhantomData,
68 | }
69 | }
70 | }
71 |
72 | impl Hittable for AARotation {
73 | fn hit(&self, ray: &Ray, unit_limit: std::ops::Range) -> Option> {
74 | let rotated_origin = Axis::rotate(&ray.origin, -self.radian);
75 | let rotated_direction = Axis::rotate(&ray.direction, -self.radian);
76 | let rotated_ray = Ray::new(rotated_origin, rotated_direction, ray.departure_time);
77 | self.object.hit(&rotated_ray, unit_limit).map(|mut record| {
78 | record.point = Axis::rotate(&record.point, self.radian);
79 | record.normal = Axis::rotate(&record.normal, self.radian);
80 | record
81 | })
82 | }
83 |
84 | #[allow(clippy::cast_precision_loss)] // 0, 1 is small enough
85 | fn bbox(&self, time_limit: std::ops::Range) -> Option {
86 | self.bbox_cache
87 | .get_or_init(|| {
88 | self.object.bbox(time_limit).map(|bbox| {
89 | let mut point_min = Point3::new(f64::INFINITY, f64::INFINITY, f64::INFINITY);
90 | let mut point_max =
91 | Point3::new(f64::NEG_INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
92 |
93 | for i in 0..2_usize {
94 | for j in 0..2_usize {
95 | for k in 0..2_usize {
96 | let x =
97 | (i as f64).mul_add(bbox.max().x, (1 - i) as f64 * bbox.min().x);
98 | let y =
99 | (j as f64).mul_add(bbox.max().y, (1 - j) as f64 * bbox.min().y);
100 | let z =
101 | (k as f64).mul_add(bbox.max().z, (1 - k) as f64 * bbox.min().z);
102 |
103 | let rotated_point =
104 | Axis::rotate(&Point3::new(x, y, z), self.radian);
105 |
106 | for c in 0..3 {
107 | point_min[c] = point_min[c].min(rotated_point[c]);
108 | point_max[c] = point_max[c].max(rotated_point[c]);
109 | }
110 | }
111 | }
112 | }
113 |
114 | AABB::new(point_min, point_max)
115 | })
116 | })
117 | .clone()
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/src/hittable/transform/translation.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | hittable::{HitRecord, Hittable},
3 | prelude::*,
4 | };
5 |
6 | #[derive(Debug, Clone)]
7 | pub struct Translation {
8 | object: T,
9 | movement: Vec3,
10 | }
11 |
12 | impl Translation {
13 | pub const fn new(object: T, movement: Vec3) -> Self {
14 | Self { object, movement }
15 | }
16 | }
17 |
18 | impl Hittable for Translation {
19 | fn hit(&self, ray: &Ray, unit_limit: std::ops::Range) -> Option> {
20 | let moved_ray = Ray::new(
21 | &ray.origin - &self.movement,
22 | ray.direction.clone(),
23 | ray.departure_time,
24 | );
25 | self.object.hit(&moved_ray, unit_limit).map(|mut record| {
26 | record.point += &self.movement;
27 | record
28 | })
29 | }
30 |
31 | fn bbox(&self, time_limit: std::ops::Range) -> Option {
32 | self.object
33 | .bbox(time_limit)
34 | .map(|bbox| AABB::new(bbox.min() + &self.movement, bbox.max() + &self.movement))
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/src/internal/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod rayon_seq_iter;
2 |
--------------------------------------------------------------------------------
/src/internal/rayon_seq_iter.rs:
--------------------------------------------------------------------------------
1 | use {
2 | rayon::iter::{IndexedParallelIterator, ParallelIterator},
3 | std::{cmp::Ordering, collections::BinaryHeap, sync::mpsc::channel},
4 | };
5 |
6 | #[derive(Debug)]
7 | struct ReverseFirst(usize, T);
8 |
9 | impl PartialEq for ReverseFirst {
10 | fn eq(&self, rhs: &Self) -> bool {
11 | rhs.0.eq(&self.0)
12 | }
13 | }
14 |
15 | impl Eq for ReverseFirst {}
16 |
17 | impl PartialOrd for ReverseFirst {
18 | fn partial_cmp(&self, rhs: &Self) -> Option {
19 | rhs.0.partial_cmp(&self.0)
20 | }
21 | }
22 |
23 | impl Ord for ReverseFirst {
24 | fn cmp(&self, o: &Self) -> Ordering {
25 | o.0.cmp(&self.0)
26 | }
27 | }
28 |
29 | // TODO: Write document for this complex but useful function
30 | pub trait SeqForEach: IndexedParallelIterator {
31 | fn seq_for_each_with(self, setup: SetUp, mut f: F) -> Result<(), E>
32 | where
33 | SetUp: FnOnce() -> Result + Send,
34 | F: FnMut(&mut SetUpRet, Self::Item) -> Result<(), E> + Send,
35 | {
36 | let (tx, rx) = channel();
37 | let mut ret = Ok(());
38 |
39 | rayon::scope(|s| {
40 | s.spawn(|_| {
41 | self.enumerate().for_each_with(tx, |sender, idx_and_item| {
42 | let _ = sender.send(idx_and_item);
43 | })
44 | });
45 | s.spawn(|_| {
46 | let mut context = match setup() {
47 | Ok(context) => context,
48 | Err(e) => {
49 | ret = Err(e);
50 | return;
51 | }
52 | };
53 | let mut expected = 0;
54 | let mut heap = BinaryHeap::new();
55 | for (idx, item) in rx {
56 | heap.push(ReverseFirst(idx, item));
57 | while let Some(&ReverseFirst(idx, _)) = heap.peek() {
58 | if idx != expected {
59 | break;
60 | }
61 | let ReverseFirst(_idx, item) = heap.pop().unwrap();
62 | if let e @ Err(_) = f(&mut context, item) {
63 | ret = e;
64 | return;
65 | }
66 | expected += 1;
67 | }
68 | }
69 | });
70 | });
71 |
72 | ret
73 | }
74 | }
75 |
76 | impl SeqForEach for P {}
77 |
--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![deny(clippy::all, clippy::pedantic, clippy::nursery)]
2 | #![deny(missing_debug_implementations, rust_2018_idioms)]
3 | #![deny(warnings)]
4 | #![allow(clippy::module_name_repetitions, clippy::cast_possible_truncation)]
5 |
6 | pub mod camera;
7 | pub mod hittable;
8 | pub mod material;
9 | pub mod painter;
10 | pub mod prelude;
11 | pub mod texture;
12 |
13 | mod internal;
14 |
--------------------------------------------------------------------------------
/src/material/dielectric.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | hittable::HitRecord,
4 | material::{reflect, Material, ScatterRecord},
5 | prelude::*,
6 | },
7 | std::fmt::Debug,
8 | };
9 |
10 | pub trait ReflectProbabilityCurve: Debug + Send + Sync {
11 | fn reflect_prob(&self, cos_theta: f64, refractive: f64) -> f64;
12 | }
13 |
14 | #[derive(Debug)]
15 | pub struct Glass {}
16 |
17 | impl ReflectProbabilityCurve for Glass {
18 | fn reflect_prob(&self, cos_theta: f64, refractive: f64) -> f64 {
19 | let r0 = (1.0 - refractive) / (1.0 + refractive);
20 | let r0 = r0 * r0;
21 | (1.0 - r0).mul_add((1.0 - cos_theta).powi(5), r0)
22 | }
23 | }
24 |
25 | #[derive(Debug)]
26 | pub struct Dielectric {
27 | color: Color,
28 | enter_refractive: f64,
29 | outer_refractive: f64,
30 | reflect_curve: Option>,
31 | }
32 |
33 | impl Dielectric {
34 | #[must_use]
35 | pub fn new(color: Color, refractive: f64) -> Self {
36 | let enter_refractive = 1.0 / refractive;
37 | let outer_refractive = refractive;
38 | Self {
39 | color,
40 | enter_refractive,
41 | outer_refractive,
42 | reflect_curve: None,
43 | }
44 | }
45 |
46 | pub fn reflect_curve(mut self, reflect_curve: R) -> Self {
47 | self.reflect_curve = Some(Box::new(reflect_curve));
48 | self
49 | }
50 |
51 | fn refract(&self, ray: &Ray, hit: &HitRecord<'_>) -> Option {
52 | let dir = ray.direction.unit();
53 | let cos_theta = (-&dir).dot(&hit.normal);
54 | let sin_theta = (1.0 - cos_theta * cos_theta).sqrt();
55 | let refractive = if hit.outside {
56 | self.enter_refractive
57 | } else {
58 | self.outer_refractive
59 | };
60 | if refractive * sin_theta > 1.0 {
61 | return None;
62 | }
63 | let reflect_prob = self
64 | .reflect_curve
65 | .as_ref()
66 | .map_or(0.0, |r| r.reflect_prob(cos_theta, refractive));
67 | if Random::normal() < reflect_prob {
68 | return None;
69 | }
70 | let r_parallel = refractive * (&dir + cos_theta * &hit.normal);
71 | let r_perpendicular = -(1.0 - r_parallel.length_squared()).sqrt() * &hit.normal;
72 | let r = r_parallel + r_perpendicular;
73 | Some(Ray::new(hit.point.clone(), r, ray.departure_time))
74 | }
75 | }
76 |
77 | impl Material for Dielectric {
78 | fn scatter(&self, ray: &Ray, hit: HitRecord<'_>) -> Option {
79 | let refract = self
80 | .refract(ray, &hit)
81 | .unwrap_or_else(|| reflect(ray, &hit));
82 | Some(ScatterRecord {
83 | color: self.color.clone(),
84 | ray: refract,
85 | })
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/material/isotropic.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | material::{Material, ScatterRecord},
3 | prelude::*,
4 | };
5 |
6 | #[derive(Debug, Clone)]
7 | pub struct Isotropic {
8 | color: Color,
9 | }
10 |
11 | impl Isotropic {
12 | #[must_use]
13 | pub const fn new(color: Color) -> Self {
14 | Self { color }
15 | }
16 | }
17 |
18 | impl Material for Isotropic {
19 | fn scatter(
20 | &self, ray: &Ray, hit: crate::hittable::HitRecord<'_>,
21 | ) -> Option {
22 | let scattered_ray = Ray::new(hit.point, Vec3::random_in_unit_sphere(), ray.departure_time);
23 | Some(ScatterRecord {
24 | ray: scattered_ray,
25 | color: self.color.clone(),
26 | })
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/material/lambertian.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | hittable::HitRecord,
3 | material::{Material, ScatterRecord},
4 | prelude::*,
5 | texture::Texture,
6 | };
7 |
8 | #[derive(Debug, Clone)]
9 | pub enum LambertianMathType {
10 | Approximates,
11 | True,
12 | Hemisphere,
13 | }
14 |
15 | impl LambertianMathType {
16 | #[must_use]
17 | pub fn scatter_ray(&self, ray: &Ray, hit: HitRecord<'_>) -> Ray {
18 | match self {
19 | Self::Approximates => Ray::new(
20 | hit.point,
21 | hit.normal + Vec3::random_in_unit_sphere(),
22 | ray.departure_time,
23 | ),
24 | Self::True => Ray::new(
25 | hit.point,
26 | hit.normal + Vec3::random_unit(),
27 | ray.departure_time,
28 | ),
29 | Self::Hemisphere => Ray::new(
30 | hit.point,
31 | Vec3::random_unit_dir(&hit.normal),
32 | ray.departure_time,
33 | ),
34 | }
35 | }
36 | }
37 |
38 | #[derive(Debug, Clone)]
39 | pub struct Lambertian {
40 | texture: T,
41 | math_type: LambertianMathType,
42 | }
43 |
44 | impl Lambertian {
45 | #[must_use]
46 | pub fn new(texture: T) -> Self {
47 | Self {
48 | texture,
49 | math_type: LambertianMathType::True,
50 | }
51 | }
52 |
53 | #[must_use]
54 | pub fn math_type(mut self, value: LambertianMathType) -> Self {
55 | self.math_type = value;
56 | self
57 | }
58 | }
59 |
60 | impl Material for Lambertian {
61 | fn scatter(&self, ray: &Ray, hit: HitRecord<'_>) -> Option {
62 | let color = self.texture.color(hit.u, hit.v, &hit.point);
63 | let new_ray = self.math_type.scatter_ray(ray, hit);
64 | Some(ScatterRecord {
65 | color,
66 | ray: new_ray,
67 | })
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/src/material/light.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | hittable::HitRecord,
3 | material::{Material, ScatterRecord},
4 | prelude::*,
5 | texture::Texture,
6 | };
7 |
8 | #[derive(Debug, Clone)]
9 | pub struct DiffuseLight {
10 | texture: T,
11 | multiplier: f64,
12 | }
13 |
14 | impl DiffuseLight {
15 | pub const fn new(texture: T) -> Self {
16 | Self {
17 | texture,
18 | multiplier: 1.0,
19 | }
20 | }
21 |
22 | pub const fn multiplier(mut self, multiplier: f64) -> Self {
23 | self.multiplier = multiplier;
24 | self
25 | }
26 | }
27 |
28 | impl Material for DiffuseLight {
29 | fn scatter(&self, _ray: &Ray, _hit: HitRecord<'_>) -> Option {
30 | None
31 | }
32 |
33 | fn emitted(&self, u: f64, v: f64, point: &Point3) -> Option {
34 | Some(>::into(self.texture.color(u, v, point)) * self.multiplier)
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/src/material/metal.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | hittable::HitRecord,
3 | material::{Material, ScatterRecord},
4 | prelude::*,
5 | texture::Texture,
6 | };
7 |
8 | #[derive(Debug)]
9 | pub struct Metal {
10 | texture: T,
11 | fuzz: f64,
12 | }
13 |
14 | impl Metal {
15 | #[must_use]
16 | pub fn new(texture: T) -> Self {
17 | Self { texture, fuzz: 0.0 }
18 | }
19 |
20 | #[must_use]
21 | pub fn fuzz(mut self, fuzz: f64) -> Self {
22 | self.fuzz = clamp(fuzz.abs(), 0.0..=1.0);
23 | self
24 | }
25 |
26 | fn reflect(&self, ray: &Ray, hit: &HitRecord<'_>) -> Ray {
27 | let dir = ray.direction.unit();
28 | let mut reflected_dir = &dir - 2.0 * dir.dot(&hit.normal) * &hit.normal;
29 | reflected_dir += self.fuzz * Vec3::random_in_unit_sphere();
30 | Ray::new(hit.point.clone(), reflected_dir, ray.departure_time)
31 | }
32 | }
33 |
34 | impl Material for Metal {
35 | fn scatter(&self, ray: &Ray, hit: HitRecord<'_>) -> Option {
36 | let color = self.texture.color(hit.u, hit.v, &hit.point);
37 | let reflected = self.reflect(ray, &hit);
38 | if reflected.direction.dot(&hit.normal) > 0.0 {
39 | Some(ScatterRecord {
40 | color,
41 | ray: reflected,
42 | })
43 | } else {
44 | None
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/material/mod.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{hittable::HitRecord, prelude::*},
3 | std::sync::Arc,
4 | };
5 |
6 | pub(crate) mod dielectric;
7 | pub(crate) mod isotropic;
8 | pub(crate) mod lambertian;
9 | pub(crate) mod light;
10 | pub(crate) mod metal;
11 |
12 | pub use {
13 | dielectric::{Dielectric, Glass},
14 | isotropic::Isotropic,
15 | lambertian::{Lambertian, LambertianMathType},
16 | light::DiffuseLight,
17 | metal::Metal,
18 | };
19 |
20 | #[derive(Debug)]
21 | pub struct ScatterRecord {
22 | pub color: Color,
23 | pub ray: Ray,
24 | }
25 |
26 | pub trait Material: Send + Sync {
27 | fn scatter(&self, ray: &Ray, hit: HitRecord<'_>) -> Option;
28 | #[allow(unused_variables)]
29 | fn emitted(&self, u: f64, v: f64, point: &Point3) -> Option {
30 | None
31 | }
32 | }
33 |
34 | impl Material for Arc {
35 | fn scatter(&self, ray: &Ray, hit: HitRecord<'_>) -> Option {
36 | self.as_ref().scatter(ray, hit)
37 | }
38 |
39 | fn emitted(&self, u: f64, v: f64, point: &Point3) -> Option {
40 | self.as_ref().emitted(u, v, point)
41 | }
42 | }
43 |
44 | pub(crate) fn reflect(ray: &Ray, hit: &HitRecord<'_>) -> Ray {
45 | let dir = ray.direction.unit();
46 | let reflected_dir = &dir - 2.0 * dir.dot(&hit.normal) * &hit.normal;
47 | Ray::new(hit.point.clone(), reflected_dir, ray.departure_time)
48 | }
49 |
--------------------------------------------------------------------------------
/src/painter.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{internal::rayon_seq_iter::SeqForEach, prelude::*},
3 | log::info,
4 | rayon::{prelude::*, ThreadPool, ThreadPoolBuilder},
5 | std::{
6 | fs::File,
7 | io::{BufWriter, Write},
8 | iter::FromIterator,
9 | ops::{Index, IndexMut},
10 | path::Path,
11 | sync::atomic::{AtomicBool, AtomicUsize, Ordering},
12 | },
13 | };
14 |
15 | #[derive(Debug)]
16 | pub struct PPMImage {
17 | width: usize,
18 | height: usize,
19 | colors: Vec,
20 | }
21 |
22 | impl PPMImage {
23 | #[must_use]
24 | pub fn new(width: usize, height: usize) -> Self {
25 | let colors = vec![Color::default(); width * height];
26 | Self {
27 | width,
28 | height,
29 | colors,
30 | }
31 | }
32 |
33 | /// # Errors
34 | /// When open or write to file failed
35 | pub fn save>(&self, path: P) -> std::io::Result<()> {
36 | let mut file = File::create(path)?;
37 | write!(
38 | &mut file,
39 | "P3\n{width} {height}\n255\n",
40 | width = self.width,
41 | height = self.height
42 | )?;
43 |
44 | for row in 0..self.height {
45 | for column in 0..self.width {
46 | let index = row * self.width + column;
47 | let color = &self.colors[index].i();
48 | writeln!(
49 | &mut file,
50 | "{r} {g} {b}",
51 | r = color.r,
52 | g = color.g,
53 | b = color.b
54 | )?;
55 | }
56 | }
57 |
58 | Ok(())
59 | }
60 |
61 | /// # Errors
62 | ///
63 | /// When image pixel count is not divisible by new width
64 | pub fn reshape(&mut self, width: usize) -> Result<(), &'static str> {
65 | if self.colors.len() % width == 0 {
66 | self.width = width;
67 | self.height = self.colors.len() / width;
68 | Ok(())
69 | } else {
70 | Err("Shape invalid")
71 | }
72 | }
73 | }
74 |
75 | impl FromIterator for PPMImage {
76 | fn from_iter>(iter: T) -> Self {
77 | Vec::from_iter(iter).into()
78 | }
79 | }
80 |
81 | impl From for PPMImage
82 | where
83 | T: Into>,
84 | {
85 | fn from(container: T) -> Self {
86 | let colors = container.into();
87 | Self {
88 | height: 1,
89 | width: colors.len(),
90 | colors,
91 | }
92 | }
93 | }
94 |
95 | impl Index<(usize, usize)> for PPMImage {
96 | type Output = Color;
97 | fn index(&self, (row, col): (usize, usize)) -> &Self::Output {
98 | self.index(row * self.width + col)
99 | }
100 | }
101 |
102 | impl Index for PPMImage {
103 | type Output = Color;
104 | fn index(&self, index: usize) -> &Self::Output {
105 | self.colors.index(index)
106 | }
107 | }
108 |
109 | impl IndexMut<(usize, usize)> for PPMImage {
110 | fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut Self::Output {
111 | self.index_mut(row * self.width + col)
112 | }
113 | }
114 |
115 | impl IndexMut for PPMImage {
116 | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
117 | self.colors.index_mut(index)
118 | }
119 | }
120 |
121 | #[derive(Debug)]
122 | pub struct Painter {
123 | pub width: usize,
124 | pub height: usize,
125 | samples: usize,
126 | gamma: bool,
127 | threads: usize,
128 | parallel: bool,
129 | }
130 |
131 | struct PainterOutputContext<'c> {
132 | file: BufWriter>,
133 | cancel: &'c AtomicBool,
134 | }
135 |
136 | impl Painter {
137 | #[must_use]
138 | pub const fn new(width: usize, height: usize) -> Self {
139 | Self {
140 | width,
141 | height,
142 | gamma: true,
143 | samples: 50,
144 | threads: 0,
145 | parallel: true,
146 | }
147 | }
148 |
149 | #[must_use]
150 | pub const fn gamma(mut self, gamma: bool) -> Self {
151 | self.gamma = gamma;
152 | self
153 | }
154 |
155 | #[must_use]
156 | pub const fn samples(mut self, samples: usize) -> Self {
157 | self.samples = samples;
158 | self
159 | }
160 |
161 | #[must_use]
162 | pub const fn threads(mut self, threads: usize) -> Self {
163 | self.threads = threads;
164 | self
165 | }
166 |
167 | #[must_use]
168 | pub const fn parallel(mut self, parallel: bool) -> Self {
169 | self.parallel = parallel;
170 | self
171 | }
172 |
173 | #[allow(clippy::cast_precision_loss)] // because row and column is small enough in practice
174 | fn calculate_uv(&self, row: usize, column: usize) -> (f64, f64) {
175 | if self.samples == 1 {
176 | let u = (column as f64) / self.width as f64;
177 | let v = ((self.height - 1 - row) as f64) / self.height as f64;
178 | (u, v)
179 | } else {
180 | let u = (column as f64 + Random::normal()) / self.width as f64;
181 | let v = ((self.height - 1 - row) as f64 + Random::normal()) / self.height as f64;
182 | (u, v)
183 | }
184 | }
185 |
186 | fn create_output_file(
187 | &self, path: Option<&Path>,
188 | ) -> std::io::Result>> {
189 | let mut file: BufWriter> = if let Some(path) = path {
190 | BufWriter::new(Box::new(File::create(&path)?))
191 | } else {
192 | BufWriter::new(Box::new(std::io::sink()))
193 | };
194 |
195 | write!(
196 | &mut file,
197 | "P3\n{width} {height}\n255\n",
198 | width = self.width,
199 | height = self.height
200 | )?;
201 |
202 | Ok(file)
203 | }
204 |
205 | fn create_output_context<'c>(
206 | &self, path: Option<&Path>, cancel: &'c AtomicBool,
207 | ) -> std::io::Result> {
208 | let file = self.create_output_file(path)?;
209 | Ok(PainterOutputContext { file, cancel })
210 | }
211 |
212 | // TODO: make it return RGBInt type
213 | fn render_pixel(&self, row: usize, column: usize, uv_color: &F) -> (u8, u8, u8)
214 | where
215 | F: Fn(f64, f64) -> Vec3 + Send + Sync,
216 | {
217 | let color: Vec3 = (0..self.samples)
218 | .map(|_| {
219 | let (u, v) = self.calculate_uv(row, column);
220 | uv_color(u, v)
221 | })
222 | .sum();
223 | let color = color.into_color(self.samples, self.gamma);
224 | let color = color.i();
225 | (color.r, color.g, color.b)
226 | }
227 |
228 | fn parallel_render_row(
229 | &self, row: usize, uv_color: &F, cancel: &AtomicBool,
230 | ) -> Vec<(u8, u8, u8)>
231 | where
232 | F: Fn(f64, f64) -> Vec3 + Send + Sync,
233 | {
234 | (0..self.width)
235 | .map(|column| {
236 | if cancel.load(Ordering::Relaxed) {
237 | return (0, 0, 0);
238 | }
239 | self.render_pixel(row, column, &uv_color)
240 | })
241 | .collect::>()
242 | }
243 |
244 | fn seq_render_row(&self, row: usize, uv_color: &F) -> Vec<(u8, u8, u8)>
245 | where
246 | F: Fn(f64, f64) -> Vec3 + Send + Sync,
247 | {
248 | (0..self.width)
249 | .map(|column| self.render_pixel(row, column, &uv_color))
250 | .collect::>()
251 | }
252 |
253 | fn parallel_render_row_iter<'c, F>(
254 | &'c self, uv_color: F, cancel: &'c AtomicBool,
255 | ) -> impl IndexedParallelIterator- > + 'c
256 | where
257 | F: Fn(f64, f64) -> Vec3 + Send + Sync + 'c,
258 | {
259 | (0..self.height)
260 | .into_par_iter()
261 | .map(move |row| self.parallel_render_row(row, &uv_color, cancel))
262 | }
263 |
264 | fn seq_render_row_iter<'c, F>(
265 | &'c self, uv_color: F,
266 | ) -> impl Iterator
- > + 'c
267 | where
268 | F: Fn(f64, f64) -> Vec3 + Send + Sync + 'c,
269 | {
270 | (0..self.height).map(move |row| self.seq_render_row(row, &uv_color))
271 | }
272 |
273 | fn real_row_pixels_to_file(
274 | context: &mut PainterOutputContext<'_>, pixels: Vec<(u8, u8, u8)>,
275 | ) -> std::io::Result<()> {
276 | for pixel in pixels {
277 | writeln!(context.file, "{} {} {}", pixel.0, pixel.1, pixel.2)?;
278 | }
279 | context.file.flush()
280 | }
281 |
282 | fn row_pixels_to_file(
283 | context: &mut PainterOutputContext<'_>, pixels: Vec<(u8, u8, u8)>,
284 | ) -> std::io::Result<()> {
285 | Self::real_row_pixels_to_file(context, pixels).map_err(|e| {
286 | context.cancel.store(true, Ordering::Relaxed);
287 | e
288 | })
289 | }
290 |
291 | fn parallel_render_and_output(&self, uv_color: F, path: Option<&Path>) -> std::io::Result<()>
292 | where
293 | F: Fn(f64, f64) -> Vec3 + Send + Sync,
294 | {
295 | let cancel = AtomicBool::new(false);
296 | let finished_row = AtomicUsize::new(0);
297 |
298 | self.parallel_render_row_iter(uv_color, &cancel)
299 | .inspect(|_| {
300 | let count = finished_row.fetch_add(1, Ordering::Relaxed);
301 | info!("Scan line remaining: {}", self.height - count - 1);
302 | })
303 | .seq_for_each_with(
304 | || self.create_output_context(path, &cancel),
305 | |context, pixels| Self::row_pixels_to_file(context, pixels),
306 | )
307 | }
308 |
309 | fn setup_thread_pool(&self) -> std::io::Result {
310 | let threads = if self.threads == 0 {
311 | num_cpus::get() + 1
312 | } else {
313 | self.threads + 1
314 | };
315 | ThreadPoolBuilder::default()
316 | .num_threads(threads)
317 | .build()
318 | .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
319 | }
320 |
321 | /// # Errors
322 | ///
323 | /// When open or save to file failed
324 | pub fn draw(&self, path: &Option
, uv_color: F) -> std::io::Result<()>
325 | where
326 | P: AsRef,
327 | F: Fn(f64, f64) -> Vec3 + Send + Sync,
328 | {
329 | let path = match path {
330 | Some(ref path) => Some(path.as_ref()),
331 | None => None,
332 | };
333 |
334 | if self.parallel {
335 | let pool = self.setup_thread_pool()?;
336 |
337 | info!("Worker thread count: {}", pool.current_num_threads());
338 |
339 | pool.install(|| self.parallel_render_and_output(uv_color, path))
340 | } else {
341 | let cancel = AtomicBool::new(false); // useless in parallel mode
342 | let mut context = self.create_output_context(path, &cancel)?;
343 | for (row, pixels) in self.seq_render_row_iter(uv_color).enumerate() {
344 | info!("Scan line remaining: {}", self.height - row);
345 | Self::row_pixels_to_file(&mut context, pixels)?;
346 | }
347 | Ok(())
348 | }
349 | }
350 | }
351 |
--------------------------------------------------------------------------------
/src/prelude/aabb.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::prelude::*,
3 | std::ops::{BitOr, BitOrAssign, Range},
4 | };
5 |
6 | /// Axis aligned bounding box
7 | #[derive(Debug, Clone)]
8 | pub struct AABB {
9 | min: Point3,
10 | max: Point3,
11 | }
12 |
13 | impl AABB {
14 | #[must_use]
15 | pub const fn new(min: Point3, max: Point3) -> Self {
16 | Self { min, max }
17 | }
18 |
19 | #[must_use]
20 | pub const fn min(&self) -> &Point3 {
21 | &self.min
22 | }
23 |
24 | #[must_use]
25 | pub const fn max(&self) -> &Point3 {
26 | &self.max
27 | }
28 |
29 | #[must_use]
30 | pub fn hit(&self, ray: &Ray, unit_limit: Range) -> bool {
31 | let mut t_min = unit_limit.start;
32 | let mut t_max = unit_limit.end;
33 | for i in 0..3 {
34 | // TODO: when inv = Inf and min - origin = 0, the calculation will give a NaN
35 | let inv = 1.0 / ray.direction[i];
36 | let mut t0 = (self.min[i] - ray.origin[i]) * inv;
37 | let mut t1 = (self.max[i] - ray.origin[i]) * inv;
38 | if inv < 0.0 {
39 | std::mem::swap(&mut t0, &mut t1);
40 | }
41 | t_min = t_min.max(t0);
42 | t_max = t_max.min(t1);
43 | if t_max <= t_min {
44 | return false;
45 | }
46 | }
47 | true
48 | }
49 | }
50 |
51 | impl BitOr for &AABB {
52 | type Output = AABB;
53 |
54 | fn bitor(self, rhs: Self) -> Self::Output {
55 | let min = Point3::new_min(&self.min, &rhs.min);
56 | let max = Point3::new_max(&self.max, &rhs.max);
57 |
58 | AABB::new(min, max)
59 | }
60 | }
61 |
62 | impl BitOr for AABB {
63 | type Output = Self;
64 |
65 | fn bitor(self, rhs: Self) -> Self::Output {
66 | &self | &rhs
67 | }
68 | }
69 |
70 | impl BitOr<&Self> for AABB {
71 | type Output = Self;
72 |
73 | fn bitor(self, rhs: &Self) -> Self::Output {
74 | &self | rhs
75 | }
76 | }
77 |
78 | impl BitOr for &AABB {
79 | type Output = AABB;
80 |
81 | fn bitor(self, rhs: AABB) -> Self::Output {
82 | self | &rhs
83 | }
84 | }
85 |
86 | impl BitOrAssign<&Self> for AABB {
87 | fn bitor_assign(&mut self, rhs: &Self) {
88 | self.min = Point3::new_min(&self.min, &rhs.min);
89 | self.max = Point3::new_max(&self.max, &rhs.max);
90 | }
91 | }
92 |
93 | impl BitOrAssign for AABB {
94 | fn bitor_assign(&mut self, rhs: Self) {
95 | *self |= &rhs
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/src/prelude/color.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{
3 | prelude::{clamp, vec3::Point3},
4 | texture::Texture,
5 | },
6 | std::{borrow::Cow, ops::Mul},
7 | };
8 |
9 | macro_rules! check0to1 {
10 | ($r: ident, $g: ident, $b: ident) => {
11 | debug_assert!((0.0_f64..=1.0_f64).contains(&$r), "r = {}", $r);
12 | debug_assert!((0.0_f64..=1.0_f64).contains(&$g), "g = {}", $g);
13 | debug_assert!((0.0_f64..=1.0_f64).contains(&$b), "b = {}", $b);
14 | };
15 | }
16 |
17 | #[derive(Debug, Clone, Default)]
18 | pub struct RGBFloat {
19 | pub r: f64,
20 | pub g: f64,
21 | pub b: f64,
22 | }
23 |
24 | impl RGBFloat {
25 | pub fn new(r: f64, g: f64, b: f64) -> Self {
26 | check0to1!(r, g, b);
27 | Self { r, g, b }
28 | }
29 | }
30 |
31 | #[derive(Debug, Clone, Default)]
32 | pub struct RGBInt {
33 | pub r: u8,
34 | pub g: u8,
35 | pub b: u8,
36 | }
37 |
38 | impl RGBInt {
39 | pub const fn new(r: u8, g: u8, b: u8) -> Self {
40 | Self { r, g, b }
41 | }
42 | }
43 |
44 | impl From<&RGBFloat> for RGBInt {
45 | fn from(c: &RGBFloat) -> Self {
46 | #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
47 | // because RGBFloat r g b should be in [0..1]
48 | Self::new(
49 | (c.r * 255.0) as u8,
50 | (c.g * 255.0) as u8,
51 | (c.b * 255.0) as u8,
52 | )
53 | }
54 | }
55 |
56 | impl From<&RGBInt> for RGBFloat {
57 | fn from(c: &RGBInt) -> Self {
58 | let s = 1.0 / 255.0;
59 | Self::new(f64::from(c.r) * s, f64::from(c.g) * s, f64::from(c.b) * s)
60 | }
61 | }
62 |
63 | #[derive(Debug, Clone)]
64 | pub enum Color {
65 | Float(RGBFloat),
66 | Int(RGBInt),
67 | }
68 |
69 | impl Default for Color {
70 | fn default() -> Self {
71 | Self::Float(RGBFloat::default())
72 | }
73 | }
74 |
75 | impl Color {
76 | #[must_use]
77 | pub const fn new_int(r: u8, g: u8, b: u8) -> Self {
78 | Self::Int(RGBInt::new(r, g, b))
79 | }
80 |
81 | #[must_use]
82 | pub fn new(r: f64, g: f64, b: f64) -> Self {
83 | Self::Float(RGBFloat::new(r, g, b))
84 | }
85 |
86 | #[must_use]
87 | pub fn i(&self) -> Cow<'_, RGBInt> {
88 | match self {
89 | Self::Float(c) => Cow::Owned(c.into()),
90 | Self::Int(c) => Cow::Borrowed(c),
91 | }
92 | }
93 |
94 | #[must_use]
95 | pub fn f(&self) -> Cow<'_, RGBFloat> {
96 | match self {
97 | Self::Float(c) => Cow::Borrowed(c),
98 | Self::Int(c) => Cow::Owned(c.into()),
99 | }
100 | }
101 |
102 | #[must_use]
103 | pub fn gradient(&self, rhs: &Self, slide: f64) -> Self {
104 | let a = (1.0 - slide) * self;
105 | let b = slide * rhs;
106 | let c1 = a.f();
107 | let c2 = b.f();
108 | Self::new(c1.r + c2.r, c1.g + c2.g, c1.b + c2.b)
109 | }
110 | }
111 |
112 | impl Texture for Color {
113 | fn color(&self, _u: f64, _v: f64, _point: &Point3) -> Color {
114 | self.clone()
115 | }
116 | }
117 |
118 | impl Mul<&Color> for &Color {
119 | type Output = Color;
120 | fn mul(self, rhs: &Color) -> Self::Output {
121 | let c1 = self.f();
122 | let c2 = rhs.f();
123 | Color::new(c1.r * c2.r, c1.g * c2.g, c1.b * c2.b)
124 | }
125 | }
126 |
127 | impl Mul for &Color {
128 | type Output = Color;
129 | fn mul(self, rhs: Color) -> Self::Output {
130 | self * &rhs
131 | }
132 | }
133 |
134 | impl Mul<&Color> for Color {
135 | type Output = Self;
136 | fn mul(self, rhs: &Self) -> Self::Output {
137 | &self * rhs
138 | }
139 | }
140 |
141 | impl Mul for Color {
142 | type Output = Self;
143 | fn mul(self, rhs: Self) -> Self::Output {
144 | &self * &rhs
145 | }
146 | }
147 |
148 | impl Mul for &Color {
149 | type Output = Color;
150 | fn mul(self, rhs: f64) -> Self::Output {
151 | let c = self.f();
152 | Color::new(
153 | clamp(c.r * rhs, 0.0..=1.0),
154 | clamp(c.g * rhs, 0.0..=1.0),
155 | clamp(c.b * rhs, 0.0..=1.0),
156 | )
157 | }
158 | }
159 |
160 | impl Mul for Color {
161 | type Output = Self;
162 | fn mul(self, rhs: f64) -> Self::Output {
163 | &self * rhs
164 | }
165 | }
166 |
167 | impl Mul<&Color> for f64 {
168 | type Output = Color;
169 | fn mul(self, rhs: &Color) -> Self::Output {
170 | rhs * self
171 | }
172 | }
173 | impl Mul for f64 {
174 | type Output = Color;
175 | fn mul(self, rhs: Color) -> Self::Output {
176 | &rhs * self
177 | }
178 | }
179 |
--------------------------------------------------------------------------------
/src/prelude/mod.rs:
--------------------------------------------------------------------------------
1 | mod aabb;
2 | mod color;
3 | mod random;
4 | mod ray;
5 | mod vec3;
6 |
7 | use std::ops::{Bound, RangeBounds};
8 |
9 | pub use {
10 | aabb::AABB,
11 | color::Color,
12 | random::{Random, SeedRandom},
13 | ray::Ray,
14 | std::f64::consts::PI,
15 | vec3::{Point3, Vec3},
16 | };
17 |
18 | #[must_use]
19 | pub fn clamp>(val: f64, range: R) -> f64 {
20 | let start = match range.start_bound() {
21 | Bound::Included(&x) | Bound::Excluded(&x) => x,
22 | _ => std::f64::NEG_INFINITY,
23 | };
24 | let end = match range.end_bound() {
25 | Bound::Included(&x) | Bound::Excluded(&x) => x,
26 | _ => std::f64::INFINITY,
27 | };
28 | if start > val {
29 | start
30 | } else if val > end {
31 | end
32 | } else {
33 | val
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/prelude/random.rs:
--------------------------------------------------------------------------------
1 | use {
2 | rand::{
3 | distributions::uniform::SampleUniform, rngs::StdRng, seq::SliceRandom, thread_rng, Rng,
4 | RngCore, SeedableRng,
5 | },
6 | std::ops::Range,
7 | };
8 |
9 | #[must_use]
10 | fn normal(mut rng: R) -> f64 {
11 | rng.gen_range(0.0..=1.0)
12 | }
13 |
14 | #[must_use]
15 | fn range(mut rng: R, r: Range) -> T {
16 | rng.gen_range(r)
17 | }
18 |
19 | fn choose>(mut rng: R, values: &S) -> &T {
20 | let slice = values.as_ref();
21 | assert!(!slice.is_empty());
22 | let index = rng.gen_range(0..slice.len());
23 | &slice[index]
24 | }
25 |
26 | fn shuffle>(mut rng: R, values: &mut S) {
27 | let slice = values.as_mut();
28 | slice.shuffle(&mut rng);
29 | }
30 |
31 | #[derive(Debug)]
32 | pub struct Random();
33 |
34 | impl Random {
35 | // Return random number in range [0, 1]
36 | #[must_use]
37 | pub fn normal() -> f64 {
38 | normal(thread_rng())
39 | }
40 |
41 | #[must_use]
42 | pub fn range(r: Range) -> T {
43 | range(thread_rng(), r)
44 | }
45 |
46 | pub fn choose>(values: &S) -> &T {
47 | choose(thread_rng(), values)
48 | }
49 |
50 | pub fn shuffle>(values: &mut S) {
51 | shuffle(thread_rng(), values)
52 | }
53 | }
54 |
55 | #[derive(Debug)]
56 | pub struct SeedRandom(StdRng);
57 |
58 | impl Default for SeedRandom {
59 | fn default() -> Self {
60 | Self::random()
61 | }
62 | }
63 |
64 | impl SeedRandom {
65 | #[must_use]
66 | pub fn new(seed: u64) -> Self {
67 | Self(StdRng::seed_from_u64(seed))
68 | }
69 |
70 | #[must_use]
71 | pub fn random() -> Self {
72 | Self::new(rand::thread_rng().next_u64())
73 | }
74 |
75 | pub fn normal(&mut self) -> f64 {
76 | normal(&mut self.0)
77 | }
78 |
79 | pub fn range(&mut self, r: Range) -> T {
80 | range(&mut self.0, r)
81 | }
82 |
83 | pub fn choose<'i, 's, T, S: AsRef<[T]>>(&'i mut self, values: &'s S) -> &'s T {
84 | choose(&mut self.0, values)
85 | }
86 |
87 | pub fn shuffle>(&mut self, values: &mut S) {
88 | shuffle(&mut self.0, values)
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/prelude/ray.rs:
--------------------------------------------------------------------------------
1 | use crate::prelude::vec3::{Point3, Vec3};
2 |
3 | #[derive(Debug)]
4 | pub struct Ray {
5 | pub origin: Point3,
6 | pub direction: Vec3,
7 | pub departure_time: f64,
8 | }
9 |
10 | impl Ray {
11 | #[must_use]
12 | pub const fn new(origin: Point3, direction: Vec3, departure_time: f64) -> Self {
13 | Self {
14 | origin,
15 | direction,
16 | departure_time,
17 | }
18 | }
19 |
20 | #[must_use]
21 | pub fn position_after(&self, unit: f64) -> Point3 {
22 | &self.origin + &self.direction * unit
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/prelude/vec3.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::prelude::{clamp, Color, Random, PI},
3 | std::{
4 | fmt::Display,
5 | iter::Sum,
6 | ops::{
7 | Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Range, Sub,
8 | SubAssign,
9 | },
10 | },
11 | };
12 |
13 | #[derive(Default, Clone, Debug, PartialOrd, PartialEq)]
14 | pub struct Vec3 {
15 | pub x: f64,
16 | pub y: f64,
17 | pub z: f64,
18 | }
19 |
20 | pub type Point3 = Vec3;
21 |
22 | impl Vec3 {
23 | #[must_use]
24 | pub const fn new(x: f64, y: f64, z: f64) -> Self {
25 | Self { x, y, z }
26 | }
27 |
28 | #[must_use]
29 | pub fn new_min(a: &Self, b: &Self) -> Self {
30 | Self {
31 | x: a.x.min(b.x),
32 | y: a.y.min(b.y),
33 | z: a.z.min(b.z),
34 | }
35 | }
36 |
37 | #[must_use]
38 | pub fn new_max(a: &Self, b: &Self) -> Self {
39 | Self {
40 | x: a.x.max(b.x),
41 | y: a.y.max(b.y),
42 | z: a.z.max(b.z),
43 | }
44 | }
45 |
46 | #[must_use]
47 | pub fn random_in_unit_box() -> Self {
48 | Self::new(
49 | Random::range(-1.0..1.0),
50 | Random::range(-1.0..1.0),
51 | Random::range(-1.0..1.0),
52 | )
53 | }
54 |
55 | #[must_use]
56 | pub fn random_range(r: Range) -> Self {
57 | Self::new(
58 | Random::range(r.clone()),
59 | Random::range(r.clone()),
60 | Random::range(r),
61 | )
62 | }
63 |
64 | #[must_use]
65 | pub fn random_in_unit_sphere() -> Self {
66 | loop {
67 | let p = Self::random_in_unit_box();
68 | if p.length_squared() < 1.0 {
69 | return p;
70 | }
71 | }
72 | }
73 |
74 | #[must_use]
75 | pub fn random_in_unit_hemisphere(dir: &Self) -> Self {
76 | let u = Self::random_in_unit_sphere();
77 | if u.dot(dir) > 0.0 {
78 | u
79 | } else {
80 | -u
81 | }
82 | }
83 |
84 | #[must_use]
85 | pub fn random_unit() -> Self {
86 | let a: f64 = Random::range(0.0..(2.0 * PI));
87 | let z: f64 = Random::range(-1.0..1.0);
88 | let r = (1.0 - z * z).sqrt();
89 | Self::new(r * a.cos(), r * a.sin(), z)
90 | }
91 |
92 | #[must_use]
93 | pub fn random_unit_dir(dir: &Self) -> Self {
94 | let u = Self::random_unit();
95 | if u.dot(dir) > 0.0 {
96 | u
97 | } else {
98 | -u
99 | }
100 | }
101 |
102 | #[must_use]
103 | pub fn random_unit_disk() -> Self {
104 | loop {
105 | let p = Self::new(Random::range(-1.0..1.0), Random::range(-1.0..1.0), 0.0);
106 | if p.length_squared() < 1.0 {
107 | return p;
108 | }
109 | }
110 | }
111 |
112 | #[must_use]
113 | pub fn length_squared(&self) -> f64 {
114 | self.z
115 | .mul_add(self.z, self.x.mul_add(self.x, self.y * self.y))
116 | }
117 |
118 | #[must_use]
119 | pub fn length(&self) -> f64 {
120 | self.length_squared().sqrt()
121 | }
122 |
123 | pub fn reverse(&mut self) {
124 | self.x = -self.x;
125 | self.y = -self.y;
126 | self.z = -self.z;
127 | }
128 |
129 | #[must_use]
130 | pub fn dot(&self, rhs: &Self) -> f64 {
131 | self.z.mul_add(rhs.z, self.x.mul_add(rhs.x, self.y * rhs.y))
132 | }
133 |
134 | #[must_use]
135 | pub fn cross(&self, rhs: &Self) -> Self {
136 | Self::new(
137 | self.y * rhs.z - self.z * rhs.y,
138 | self.z * rhs.x - self.x * rhs.z,
139 | self.x * rhs.y - self.y * rhs.x,
140 | )
141 | }
142 |
143 | #[must_use]
144 | pub fn unit(&self) -> Self {
145 | self / self.length()
146 | }
147 |
148 | #[allow(clippy::cast_precision_loss)] // sample count is small enough in practice
149 | #[must_use]
150 | pub fn into_color(mut self, sample_count: usize, gamma: bool) -> Color {
151 | self /= sample_count as f64;
152 | if gamma {
153 | self.x = self.x.sqrt();
154 | self.y = self.y.sqrt();
155 | self.z = self.z.sqrt();
156 | }
157 | Color::new(
158 | clamp(self.x, 0.0..=1.0),
159 | clamp(self.y, 0.0..=1.0),
160 | clamp(self.z, 0.0..=1.0),
161 | )
162 | }
163 | }
164 |
165 | impl Display for Vec3 {
166 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
167 | f.write_fmt(format_args!("{} {} {}", self.x, self.y, self.z))
168 | }
169 | }
170 |
171 | impl Index for Vec3 {
172 | type Output = f64;
173 | fn index(&self, index: usize) -> &Self::Output {
174 | match index {
175 | 0 => &self.x,
176 | 1 => &self.y,
177 | 2 => &self.z,
178 | _ => panic!("Vec3 can only index by 0-2, {} provided", index),
179 | }
180 | }
181 | }
182 |
183 | impl IndexMut for Vec3 {
184 | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
185 | match index {
186 | 0 => &mut self.x,
187 | 1 => &mut self.y,
188 | 2 => &mut self.z,
189 | _ => panic!("Vec3 can only index by 0-2, {} provided", index),
190 | }
191 | }
192 | }
193 |
194 | impl Neg for &Vec3 {
195 | type Output = Vec3;
196 | fn neg(self) -> Self::Output {
197 | Vec3::new(-self.x, -self.y, -self.z)
198 | }
199 | }
200 |
201 | impl Neg for Vec3 {
202 | type Output = Self;
203 | fn neg(self) -> Self::Output {
204 | (&self).neg()
205 | }
206 | }
207 |
208 | impl Add for &Vec3 {
209 | type Output = Vec3;
210 | fn add(self, rhs: Self) -> Self::Output {
211 | Vec3::new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
212 | }
213 | }
214 |
215 | impl Add for &Vec3 {
216 | type Output = Vec3;
217 | fn add(self, rhs: Vec3) -> Self::Output {
218 | self + &rhs
219 | }
220 | }
221 |
222 | impl Add for Vec3 {
223 | type Output = Self;
224 | fn add(self, rhs: Self) -> Self::Output {
225 | &self + &rhs
226 | }
227 | }
228 |
229 | impl Add<&Self> for Vec3 {
230 | type Output = Self;
231 | fn add(self, rhs: &Self) -> Self::Output {
232 | &self + rhs
233 | }
234 | }
235 |
236 | impl Sub for &Vec3 {
237 | type Output = Vec3;
238 | fn sub(self, rhs: Self) -> Self::Output {
239 | Vec3::new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
240 | }
241 | }
242 |
243 | impl Sub for &Vec3 {
244 | type Output = Vec3;
245 | fn sub(self, rhs: Vec3) -> Self::Output {
246 | self - &rhs
247 | }
248 | }
249 |
250 | impl Sub for Vec3 {
251 | type Output = Self;
252 | fn sub(self, rhs: Self) -> Self::Output {
253 | &self - &rhs
254 | }
255 | }
256 |
257 | impl Sub<&Self> for Vec3 {
258 | type Output = Self;
259 | fn sub(self, rhs: &Self) -> Self::Output {
260 | &self - rhs
261 | }
262 | }
263 |
264 | impl Mul for &Vec3 {
265 | type Output = Vec3;
266 | fn mul(self, rhs: Self) -> Self::Output {
267 | Vec3::new(self.x * rhs.x, self.y * rhs.y, self.z * rhs.z)
268 | }
269 | }
270 |
271 | impl Mul for &Vec3 {
272 | type Output = Vec3;
273 | fn mul(self, rhs: Vec3) -> Self::Output {
274 | self * &rhs
275 | }
276 | }
277 |
278 | impl Mul for Vec3 {
279 | type Output = Self;
280 | fn mul(self, rhs: Self) -> Self::Output {
281 | &self * &rhs
282 | }
283 | }
284 |
285 | impl Mul<&Self> for Vec3 {
286 | type Output = Self;
287 | fn mul(self, rhs: &Self) -> Self::Output {
288 | &self * rhs
289 | }
290 | }
291 |
292 | impl Mul<&Color> for &Vec3 {
293 | type Output = Vec3;
294 | fn mul(self, rhs: &Color) -> Self::Output {
295 | let rhs = rhs.f();
296 | Vec3::new(
297 | self.x * rhs.r as f64,
298 | self.y * rhs.g as f64,
299 | self.z * rhs.b as f64,
300 | )
301 | }
302 | }
303 |
304 | impl Mul for &Vec3 {
305 | type Output = Vec3;
306 | fn mul(self, rhs: Color) -> Self::Output {
307 | self * &rhs
308 | }
309 | }
310 |
311 | impl Mul for Vec3 {
312 | type Output = Self;
313 | fn mul(self, rhs: Color) -> Self::Output {
314 | &self * &rhs
315 | }
316 | }
317 |
318 | impl Mul<&Color> for Vec3 {
319 | type Output = Self;
320 | fn mul(self, rhs: &Color) -> Self::Output {
321 | &self * rhs
322 | }
323 | }
324 |
325 | impl Mul<&Vec3> for &Color {
326 | type Output = Vec3;
327 | fn mul(self, rhs: &Vec3) -> Self::Output {
328 | rhs * self
329 | }
330 | }
331 |
332 | impl Mul<&Vec3> for Color {
333 | type Output = Vec3;
334 | fn mul(self, rhs: &Vec3) -> Self::Output {
335 | &self * rhs
336 | }
337 | }
338 |
339 | impl Mul for Color {
340 | type Output = Vec3;
341 | fn mul(self, rhs: Vec3) -> Self::Output {
342 | &self * &rhs
343 | }
344 | }
345 |
346 | impl Mul for &Color {
347 | type Output = Vec3;
348 | fn mul(self, rhs: Vec3) -> Self::Output {
349 | self * &rhs
350 | }
351 | }
352 |
353 | impl Mul for &Vec3 {
354 | type Output = Vec3;
355 | fn mul(self, rhs: f64) -> Self::Output {
356 | Vec3::new(self.x * rhs, self.y * rhs, self.z * rhs)
357 | }
358 | }
359 |
360 | impl Mul for Vec3 {
361 | type Output = Self;
362 | fn mul(self, rhs: f64) -> Self::Output {
363 | &self * rhs
364 | }
365 | }
366 |
367 | impl Mul for f64 {
368 | type Output = Vec3;
369 | fn mul(self, rhs: Vec3) -> Self::Output {
370 | rhs * self
371 | }
372 | }
373 |
374 | impl Mul<&Vec3> for f64 {
375 | type Output = Vec3;
376 | fn mul(self, rhs: &Vec3) -> Self::Output {
377 | rhs * self
378 | }
379 | }
380 |
381 | impl Div for &Vec3 {
382 | type Output = Vec3;
383 | fn div(self, rhs: f64) -> Self::Output {
384 | self * (1.0 / rhs)
385 | }
386 | }
387 |
388 | impl Div for Vec3 {
389 | type Output = Self;
390 | fn div(self, rhs: f64) -> Self::Output {
391 | self * (1.0 / rhs)
392 | }
393 | }
394 |
395 | impl AddAssign<&Self> for Vec3 {
396 | fn add_assign(&mut self, rhs: &Self) {
397 | self.x += rhs.x;
398 | self.y += rhs.y;
399 | self.z += rhs.z;
400 | }
401 | }
402 |
403 | impl AddAssign for Vec3 {
404 | fn add_assign(&mut self, rhs: Self) {
405 | self.x += rhs.x;
406 | self.y += rhs.y;
407 | self.z += rhs.z;
408 | }
409 | }
410 |
411 | impl SubAssign<&Self> for Vec3 {
412 | fn sub_assign(&mut self, rhs: &Self) {
413 | self.x -= rhs.x;
414 | self.y -= rhs.y;
415 | self.z -= rhs.z;
416 | }
417 | }
418 |
419 | impl SubAssign for Vec3 {
420 | fn sub_assign(&mut self, rhs: Self) {
421 | self.x -= rhs.x;
422 | self.y -= rhs.y;
423 | self.z -= rhs.z;
424 | }
425 | }
426 |
427 | impl MulAssign for Vec3 {
428 | fn mul_assign(&mut self, rhs: Self) {
429 | self.x *= rhs.x;
430 | self.y *= rhs.y;
431 | self.z *= rhs.z;
432 | }
433 | }
434 |
435 | impl MulAssign<&Self> for Vec3 {
436 | fn mul_assign(&mut self, rhs: &Self) {
437 | self.x *= rhs.x;
438 | self.y *= rhs.y;
439 | self.z *= rhs.z;
440 | }
441 | }
442 |
443 | impl MulAssign for Vec3 {
444 | fn mul_assign(&mut self, rhs: f64) {
445 | self.x *= rhs;
446 | self.y *= rhs;
447 | self.z *= rhs;
448 | }
449 | }
450 |
451 | impl DivAssign for Vec3 {
452 | fn div_assign(&mut self, rhs: f64) {
453 | self.x /= rhs;
454 | self.y /= rhs;
455 | self.z /= rhs;
456 | }
457 | }
458 |
459 | impl Sum for Vec3 {
460 | fn sum>(iter: I) -> Self {
461 | iter.fold(Self::default(), |acc, val| acc + val)
462 | }
463 | }
464 |
465 | impl From for Vec3 {
466 | fn from(c: Color) -> Self {
467 | let c = c.f();
468 | Self::new(c.r as f64, c.g as f64, c.b as f64)
469 | }
470 | }
471 |
--------------------------------------------------------------------------------
/src/texture/checker.rs:
--------------------------------------------------------------------------------
1 | use crate::{
2 | prelude::{Color, Point3},
3 | texture::Texture,
4 | };
5 |
6 | #[allow(missing_debug_implementations)]
7 | #[derive(Clone)]
8 | pub struct Checker {
9 | odd: T1,
10 | even: T2,
11 | }
12 |
13 | impl Checker {
14 | #[must_use]
15 | pub const fn new(odd: T1, even: T2) -> Self {
16 | Self { odd, even }
17 | }
18 | }
19 |
20 | impl Texture for Checker {
21 | fn color(&self, u: f64, v: f64, point: &Point3) -> Color {
22 | let value = (10.0 * point.x).sin() * (10.0 * point.y).sin() * (10.0 * point.z).sin();
23 | if value < 0.0 {
24 | self.odd.color(u, v, point)
25 | } else {
26 | self.even.color(u, v, point)
27 | }
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/texture/image.rs:
--------------------------------------------------------------------------------
1 | use {
2 | crate::{prelude::*, texture::Texture},
3 | image::{DynamicImage, GenericImageView},
4 | std::{
5 | fmt::{Debug, Formatter},
6 | path::Path,
7 | },
8 | };
9 |
10 | pub struct Image {
11 | img: DynamicImage,
12 | }
13 |
14 | impl Debug for Image {
15 | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
16 | f.write_fmt(format_args!(
17 | "Image {{ {}x{} }} ",
18 | self.img.width(),
19 | self.img.height()
20 | ))
21 | }
22 | }
23 |
24 | impl Image {
25 | /// # Errors
26 | ///
27 | /// When load image failed
28 | pub fn new>(p: P) -> Result {
29 | let img = image::open(p).map_err(|e| e.to_string())?;
30 | Ok(Self { img })
31 | }
32 | }
33 |
34 | impl Texture for Image {
35 | #[allow(clippy::cast_sign_loss)] // u v and width all non-negative
36 | fn color(&self, u: f64, v: f64, _point: &Point3) -> Color {
37 | let v = 1.0 - v;
38 | let mut px = (u * f64::from(self.img.width())) as u32;
39 | let mut py = (v * f64::from(self.img.height())) as u32;
40 | if px >= self.img.width() {
41 | px = self.img.width() - 1;
42 | }
43 | if py >= self.img.height() {
44 | py = self.img.height() - 1;
45 | }
46 |
47 | let color = self.img.get_pixel(px, py);
48 | Color::new_int(color.0[0], color.0[1], color.0[2])
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/texture/mod.rs:
--------------------------------------------------------------------------------
1 | use {crate::prelude::*, std::sync::Arc};
2 |
3 | pub(crate) mod checker;
4 | pub(crate) mod image;
5 | pub(crate) mod noise;
6 |
7 | pub use {
8 | self::image::Image,
9 | checker::Checker,
10 | noise::{Perlin, SmoothType},
11 | };
12 |
13 | pub trait Texture: Send + Sync {
14 | fn color(&self, u: f64, v: f64, point: &Point3) -> Color;
15 | }
16 |
17 | impl Texture for Arc {
18 | fn color(&self, u: f64, v: f64, point: &Point3) -> Color {
19 | self.as_ref().color(u, v, point)
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/texture/noise.rs:
--------------------------------------------------------------------------------
1 | use crate::{prelude::*, texture::Texture};
2 |
3 | #[derive(Debug, Clone, Eq, PartialEq)]
4 | pub enum SmoothType {
5 | None,
6 | LinearInterpolate,
7 | HermitianCubic,
8 | }
9 |
10 | #[derive(Debug, Clone, Eq, PartialEq)]
11 | enum TextureType {
12 | Normal,
13 | Turbulence(u8),
14 | Marble(u8),
15 | }
16 |
17 | #[derive(Debug, Clone, PartialEq)]
18 | enum RandomValueType {
19 | Float(f64),
20 | Vector(Vec3),
21 | }
22 |
23 | #[derive(Debug, Clone)]
24 | pub struct Perlin {
25 | texture_type: TextureType,
26 | smooth_type: SmoothType,
27 | point_count: usize,
28 | scale: f64,
29 | random_values: Vec,
30 | perm_x: Vec,
31 | perm_y: Vec,
32 | perm_z: Vec,
33 | }
34 |
35 | impl Default for RandomValueType {
36 | fn default() -> Self {
37 | Self::Float(0.0)
38 | }
39 | }
40 |
41 | impl Perlin {
42 | #[must_use]
43 | pub fn new(point_count: usize, vector: bool) -> Self {
44 | let ran = (0..point_count)
45 | .map(|_| {
46 | if vector {
47 | RandomValueType::Vector(Vec3::random_unit())
48 | } else {
49 | RandomValueType::Float(Random::normal())
50 | }
51 | })
52 | .collect();
53 | let mut perm_x = (0..point_count).collect();
54 | Random::shuffle(&mut perm_x);
55 | let mut perm_y = (0..point_count).collect();
56 | Random::shuffle(&mut perm_y);
57 | let mut perm_z = (0..point_count).collect();
58 | Random::shuffle(&mut perm_z);
59 | Self {
60 | texture_type: TextureType::Normal,
61 | smooth_type: SmoothType::HermitianCubic,
62 | point_count,
63 | scale: 1.0,
64 | random_values: ran,
65 | perm_x,
66 | perm_y,
67 | perm_z,
68 | }
69 | }
70 |
71 | #[must_use]
72 | pub const fn scale(mut self, scale: f64) -> Self {
73 | self.scale = scale;
74 | self
75 | }
76 |
77 | #[must_use]
78 | pub const fn smooth(mut self, smooth: SmoothType) -> Self {
79 | self.smooth_type = smooth;
80 | self
81 | }
82 |
83 | #[must_use]
84 | pub const fn turbulence(mut self, depth: u8) -> Self {
85 | self.texture_type = TextureType::Turbulence(depth);
86 | self
87 | }
88 |
89 | #[must_use]
90 | pub const fn marble(mut self, depth: u8) -> Self {
91 | self.texture_type = TextureType::Marble(depth);
92 | self
93 | }
94 |
95 | #[allow(clippy::cast_sign_loss)] // because we bit and with positive number before cast
96 | #[allow(clippy::cast_possible_wrap)] // because di dj dk and point_count is small enough
97 | #[allow(clippy::cast_precision_loss)] // scene is not so big
98 | #[allow(clippy::many_single_char_names)]
99 | fn noise(&self, point: &Point3) -> f64 {
100 | match self.smooth_type {
101 | SmoothType::None => {
102 | let i = (((4.0 * point.x) as isize) & (self.point_count - 1) as isize) as usize;
103 | let j = (((4.0 * point.y) as isize) & (self.point_count - 1) as isize) as usize;
104 | let k = (((4.0 * point.z) as isize) & (self.point_count - 1) as isize) as usize;
105 |
106 | match &self.random_values[self.perm_x[i] ^ self.perm_y[j] ^ self.perm_z[k]] {
107 | RandomValueType::Vector(v) => v.x,
108 | RandomValueType::Float(x) => *x,
109 | }
110 | }
111 | SmoothType::LinearInterpolate | SmoothType::HermitianCubic => {
112 | let i = point.x.floor() as isize;
113 | let j = point.y.floor() as isize;
114 | let k = point.z.floor() as isize;
115 | let u = point.x - i as f64;
116 | let v = point.y - j as f64;
117 | let w = point.z - k as f64;
118 |
119 | let mut grays: [[[RandomValueType; 2]; 2]; 2] = Default::default();
120 |
121 | (0..2).for_each(|di| {
122 | (0..2).for_each(|dj| {
123 | (0..2).for_each(|dk| {
124 | let xi = ((i + di as isize) & (self.point_count - 1) as isize) as usize;
125 | let yi = ((j + dj as isize) & (self.point_count - 1) as isize) as usize;
126 | let zi = ((k + dk as isize) & (self.point_count - 1) as isize) as usize;
127 | let index = self.perm_x[xi] ^ self.perm_y[yi] ^ self.perm_z[zi];
128 | grays[di][dj][dk] = self.random_values[index].clone();
129 | })
130 | })
131 | });
132 |
133 | interpolate(&grays, u, v, w, &self.smooth_type)
134 | }
135 | }
136 | }
137 |
138 | fn calculate_turbulence(&self, point: &Point3, depth: usize) -> f64 {
139 | let mut p = point.clone();
140 | let mut weight = 1.0;
141 |
142 | (0..depth)
143 | .map(|_| {
144 | let res = weight * self.noise(&p);
145 | weight *= 0.5;
146 | p *= 2.0;
147 | res
148 | })
149 | .sum::()
150 | .abs()
151 | }
152 | }
153 |
154 | #[allow(clippy::cast_precision_loss)] // i j k is small enough
155 | fn interpolate(
156 | c: &[[[RandomValueType; 2]; 2]; 2], u: f64, v: f64, w: f64, smooth: &SmoothType,
157 | ) -> f64 {
158 | let (mut uu, mut vv, mut ww) = (u, v, w);
159 | if smooth == &SmoothType::HermitianCubic {
160 | uu = u * u * (3.0 - 2.0 * u);
161 | vv = v * v * (3.0 - 2.0 * v);
162 | ww = w * w * (3.0 - 2.0 * w);
163 | }
164 |
165 | (0..2)
166 | .map(|i| {
167 | (0..2)
168 | .map(|j| {
169 | (0..2)
170 | .map(|k| {
171 | (i as f64).mul_add(uu, (1 - i) as f64 * (1.0 - uu))
172 | * (j as f64).mul_add(vv, (1 - j) as f64 * (1.0 - vv))
173 | * (k as f64).mul_add(ww, (1 - k) as f64 * (1.0 - ww))
174 | * match &c[i][j][k] {
175 | RandomValueType::Vector(vec) => {
176 | let weight =
177 | Vec3::new(u - i as f64, v - j as f64, w - k as f64);
178 | vec.dot(&weight)
179 | }
180 | RandomValueType::Float(x) => *x,
181 | }
182 | })
183 | .sum::()
184 | })
185 | .sum::