Merge branch 'parallelograms'

Author: DeltaPavonis

.vscode/c_cpp_properties.json

@@ -4,7 +4,6 @@
             "name": "Linux",
             "includePath": [
                 "${workspaceFolder}/**",
-                "/home/kxiao/devel/competitive/kxlib"
             ],
             "defines": [],
             "compilerPath": "/usr/bin/gcc",

TODO.md

@@ -0,0 +1,15 @@
+# TODO
+
+### Features
+- [ ] Spatial and surface textures
+- [ ] Instancing (This enables easy object translation and/or rotation)
+- [ ] Volumes (smoke, fog, etc)
+    - Idea: Procedurally generate volumes, so that they have a more natural shape. Look into Perlin noise.
+
+### Optimizations
+- [ ] Optimize BVH by compressing the binary tree to an array. This improves cache locality.
+    - Don't forget to build the BVH over a copy of the primitives, as we already do. This is what they do in PBR.
+- [ ] Use C++20 concepts to guarantee that `Camera::render()` uses compile-time polymorphism rather than runtime polymorphism and dynamic dispatch, when possible.
+
+### Documentation
+- [x] Add comments to the `aabb` fields of Sphere and Parallelogram.

rendered_images/cornell_box_1.png

@@ -125,18 +125,31 @@ class AABB {
     }
 
     /* Updates (possibly expands) this `AABB` to also bound the `AABB` `other`. */
-    void merge_with(const AABB &other) {
+    auto& merge_with(const AABB &other) {
         /* Just combine the x-, y-, and z- intervals with those from `other` */
         x.merge_with(other.x);
         y.merge_with(other.y);
         z.merge_with(other.z);
+        return *this;
     }
 
     /* Updates (possibly expands) this `AABB` to also bound the `Point3D` `p`. */
-    void merge_with(const Point3D &p) {
+    auto& merge_with(const Point3D &p) {
         x.merge_with(p.x);
         y.merge_with(p.y);
         z.merge_with(p.z);
+        return *this;
+    }
+
+    /* Setters */
+
+    /* Pads all axes with length less than `min_axis_length` to have length exactly
+    `min_axis_length` (well, "exactly" as far as floating-point arithmetic can give you). */
+    auto& ensure_min_axis_length(double min_axis_length) {
+        if (x.size() < min_axis_length) {x.pad_with((min_axis_length - x.size()) / 2);}
+        if (y.size() < min_axis_length) {y.pad_with((min_axis_length - y.size()) / 2);}
+        if (z.size() < min_axis_length) {z.pad_with((min_axis_length - z.size()) / 2);}
+        return *this;
     }
 
     /* Overload `operator<<` to allow printing `AABB`s to output streams */
@@ -146,7 +159,10 @@ class AABB {
 
     /* The default constructor contructs an empty `AABB`; that is, the `AABB` where all intervals
     are the empty interval `Interval::empty()`. Note: Prefer using the named constructor
-    `AABB::empty()` instead; its functionality is equivalent, and it is more readable.  */
+    `AABB::empty()` instead; its functionality is equivalent, and it is more readable. This
+    default constructor exists merely to allow other classes which have an `AABB` as a member
+    to themselves be default constructible without having to specify a default member initializer
+    for fields of type `AABB`. */
     AABB() : AABB(Interval::empty(), Interval::empty(), Interval::empty()) {}
 
     /* --- NAMED CONSTRUCTORS --- */
@@ -160,17 +176,20 @@ class AABB {
 
     /* Constructs an AABB (Axis-Aligned Bounding Box) consisting of all points with x-coordinate
     in the interval `x_`, y-coordinate in the interval `y_`, and z-coordinate in the range `z_`.
-    In other words, this creates the AABB from the three "slabs" `x_`, `y_`, and `z_`. */
-    static AABB from_intervals(const Interval &x_, const Interval &y_, const Interval &z_) {
+    In other words, this creates the AABB from the three "slabs" (axis intervals) `x_`, `y_`, and
+    `z_`. */
+    static AABB from_axis_intervals(const Interval &x_, const Interval &y_, const Interval &z_) {
         return AABB(x_, y_, z_);
     }
 
-    /* Constructs an AABB (Axis-Aligned Bounding Box) with extreme points `a` and `b`; that is,
-    the smallest axis-aligned bounding box that contains the points `a` and `b`. */
-    static AABB from_extrema(const Point3D &a, const Point3D &b) {
-        return AABB(Interval(std::fmin(a.x, b.x), std::fmax(a.x, b.x)),
-                    Interval(std::fmin(a.y, b.y), std::fmax(a.y, b.y)),
-                    Interval(std::fmin(a.z, b.z), std::fmax(a.z, b.z)));
+    /* Constructs the minimum-volume AABB (Axis-Aligned Bounding Box) containing all the points
+    specified in `points`. */
+    static AABB from_points(std::initializer_list<Point3D> points) {
+        auto ret = AABB::empty();
+        for (const auto &p : points) {
+            ret.merge_with(p);
+        }
+        return ret;
     }
 
     /* Returns the minimum-volume `AABB` that contains both of the `AABB`s `a` and `b`.

rendered_images/empty_cornell_box.png

@@ -0,0 +1,87 @@
+#ifndef BOX_SURFACE_H
+#define BOX_SURFACE_H
+
+#include <array>
+#include "hittable.h"
+#include "parallelogram.h"
+#include "scene.h"
+
+/* `Box` is an abstraction over a 3D box - a rectangular prism - in 3D space. */
+class Box : public Hittable {
+    /* `faces` holds the six faces of this `Box`. */
+    Scene faces;
+    /* `material`: The material for the surface of this `Box`. */
+    std::shared_ptr<Material> material;
+
+public:
+
+    /* A `Box` is practically identical to a `Scene`, so the abstract functions inherited from
+    `Hittable` can just be implemented in terms of the same functions for `Scene`. */
+
+    /* Returns a `hit_info` representing the earliest (minimum hit-time) intersection of the ray
+    `ray` with this `Box` in the time itnerval `ray_times`. If no such intersection exists, then
+    an empty `std::optional<hit_info>` is returned. */
+    std::optional<hit_info> hit_by(const Ray3D &ray, const Interval &ray_times) const override {
+        /* Simply just delegate this to the `Scene`; this returns the earliest intersection of
+        `ray` in the time interval `ray_times` with the six faces of the box, as desired. */
+        return faces.hit_by(ray, ray_times);
+    }
+
+    /* Returns the primitive components of this `Box`; namely, its six `Parallelogram`
+    faces, which contributes to the construction of more efficient and complete
+    `BVH`s. See the comments in `Hittable::get_primitive_components()` for a more
+    detailed explanation. */
+    std::vector<std::shared_ptr<Hittable>> get_primitive_components() const override {
+        return faces.get_primitive_components();
+    }
+
+    /* Prints this `Box` to the `std::ostream` specified by `os`. */
+    void print_to(std::ostream &os) const override {
+        os << "Box {faces: " << faces << "} " << std::flush;
+    }
+
+    /* Returns the `AABB` for this `Box`. */
+    AABB get_aabb() const override {
+        /* Once more, we delegate this to the `Scene` field. */
+        return faces.get_aabb();
+    }
+
+    /* --- CONSTRUCTORS --- */
+
+    /* Constructs a `Box` with opposite vertices `vertex` and `opposite_vertex`, as well as
+    material specified by `material_`. */
+    Box(const Point3D &vertex, const Point3D &opposite_vertex,
+        std::shared_ptr<Material> material_)
+        : material{std::move(material_)}
+    {
+
+        /* Compute `min_coordinates` and `max_coordinates`, which respectively are the points with
+        all minimal and all maximal x-, y-, and z- coordinates from the given points `vertex` and
+        `opposite_vertex`. Observe that `min_coordinates` and `max_coordinates` are both vertices
+        of the box; in fact, they are opposite vertices of the box. */
+        Point3D min_coordinates, max_coordinates;
+        for (int i = 0; i < 3; ++i) {
+            min_coordinates[i] = std::fmin(vertex[i], opposite_vertex[i]);
+            max_coordinates[i] = std::fmax(vertex[i], opposite_vertex[i]);
+        }
+
+        /* Precompute the edge vectors of the box; namely, the x-, y-, and z- displacement vectors
+        from `min_coordinates` to `max_coordinates`. */
+        auto side_x = Vec3D{max_coordinates.x - min_coordinates.x, 0, 0};
+        auto side_y = Vec3D{0, max_coordinates.y - min_coordinates.y, 0};
+        auto side_z = Vec3D{0, 0, max_coordinates.z - min_coordinates.z};
+
+        /* A `Box` is represented by 6 parallelogram (specifcially, rectangular) faces.
+        `min_coordinates` and `max_coordinates` eachlie on three of those faces. We add
+        the 6 faces to `faces`. */
+        faces.add(std::make_shared<Parallelogram>(min_coordinates, side_x, side_y, material));
+        faces.add(std::make_shared<Parallelogram>(min_coordinates, side_x, side_z, material));
+        faces.add(std::make_shared<Parallelogram>(min_coordinates, side_y, side_z, material));
+
+        faces.add(std::make_shared<Parallelogram>(max_coordinates, -side_x, -side_y, material));
+        faces.add(std::make_shared<Parallelogram>(max_coordinates, -side_x, -side_z, material));
+        faces.add(std::make_shared<Parallelogram>(max_coordinates, -side_y, -side_z, material));
+    }
+};
+
+#endif

rendered_images/raining_on_the_dance_floor.png

@@ -108,9 +108,10 @@ class BVH : public Hittable {
     `NUM_BUCKETS` = the number of buckets to test
     */
     const size_t MAX_PRIMITIVES_IN_NODE, NUM_BUCKETS;
-    /* `total_bvh_nodes` = the number of `BVHNode`s in this `BVH` tree. This does not count
-    the `Scene`s made in `BVHNode::as_leaf_node()`, which the leaf `BVHNodes` point to. */
-    size_t total_bvh_nodes = 0;
+    /* `total_bvhnodes` = the number of `BVHNode`s in this `BVH` tree. This does not count
+    the `Scene`s made in `BVHNode::as_leaf_node()`, which the leaf `BVHNodes` point to. That is,
+    this does not count the actual number of BVH nodes; this counts the number of `BVHNode`s. */
+    size_t total_bvhnodes = 0;
 
     /* Used to have "free on memory that was not `malloc`ed" error. Fixed it with this change:
     before, `objects` was a vector of `Hittable*`, and in the `start == end - 1` condition seems
@@ -125,7 +126,7 @@ class BVH : public Hittable {
     memory, and when the second reference counter drops to 0, it tries to destroy the object again,
     leading to the double-free error. */
     auto build(std::span<std::shared_ptr<Hittable>> objects) {
-        ++total_bvh_nodes;
+        ++total_bvhnodes;
 
         /* If there is only one primitive left, then we will return a leaf `BVHNode`
         (a `BVHNode` whose children are both primitives) that just contains that one primitive. */
@@ -396,18 +397,22 @@ class BVH : public Hittable {
         : MAX_PRIMITIVES_IN_NODE{max_primitives_in_node},
           NUM_BUCKETS{num_buckets}
     {
-        std::cout << "Building BVH over " << world.size() << " primitives..." << std::endl;
+        /* Build the Bounding Volume Hierarchy over the primitive components of the `Hittable`
+        objects in the scene, rather than just the objects themselves. This is because
+        `Hittable` objects may be compound; they may contain other `Hittable`s. Building a
+        `BVH` over just the `Hittable` objects themselves could therefore */
+        auto primitive_components = world.get_primitive_components();
+
+        std::cout << "Building BVH over " << world.size() << " objects ("
+                  << primitive_components.size() << " primitives)..." << std::endl;
         auto start = std::chrono::steady_clock::now();
 
-        /* Create a copy of the objects list of `world`, because `world` is passed as `const&`, but
-        we need to modify the objects list when building the `BVH` (specifically, we may need to
-        rearrange it using `std::partition`) */
-        std::vector<std::shared_ptr<Hittable>> objects_copy = world;
-        root = build(objects_copy);
+        /* Build the `BVH` */
+        root = build(primitive_components);
 
         std::cout << "Constructed BVH in "
                   << ms_diff(start, std::chrono::steady_clock::now())
-                  << "ms (created " << total_bvh_nodes << " BVHNodes total)\n" << std::endl;
+                  << "ms (created " << total_bvhnodes << " BVHNodes total)\n" << std::endl;
     }
 };
 

src/aabb.h

@@ -62,7 +62,7 @@ class Camera {
     of the defocus disk. Both are determined by `focal_length`, `defocus_angle`,  and
     `cam_basis_x/y`. */
     Vec3D defocus_disk_x, defocus_disk_y;
-    /* Coordinates of the top-left image pixel */
+    /* Coordinates of the top-left image pixel (calculated in `init()`) */
     Point3D pixel00_loc;
     /* Number of rays sampled per pixel, 100 by default */
     size_t samples_per_pixel = 100;
@@ -76,6 +76,10 @@ class Camera {
     determined from the vertical FOVof 90 degrees  and the aspect ratio of the images in `init()`.
     */
     std::optional<double> vertical_fov{90}, horizontal_fov;
+    /* `background` = The default background color of scenes rendered by this `Camera`. That is,
+    whenever a ray hits no object in the scene, this color is returned as the color of that ray.
+    `RGB::from_mag(0.5)` (gray; halfway between white and black) by default. */
+    RGB background{RGB::from_mag(0.5)};
 
     /* Set the values of `viewport_w`, `viewport_h`, `pixel_delta_x`, `pixel_delta_y`,
     `upper_left_corner`, and `pixel00_loc` based on `image_w` and `image_h`. This function
@@ -238,14 +242,15 @@ class Camera {
             we always return `RGB::zero()` when a ray flies into the background). As a result,
             all light in the resulting render comes from an actual light source, and not just
             from the background. */
+            return background;
             return RGB::zero();
 
             /* If this ray doesn't intersect any object in the scene, then its color is determined
             by the background. Here, the background is a blue-to-white gradient depending on the
             ray's y-coordinate; bluer for lesser y-coordinates and whiter for larger y-coordinates
             (so bluer at the top and whiter at the bottom). */
-            // return lerp(RGB::from_mag(1, 1, 1), RGB::from_mag(0.5, 0.7, 1),
-                        // 0.5 * ray.dir.unit_vector().y + 0.5);
+            return lerp(RGB::from_mag(1, 1, 1), RGB::from_mag(0.5, 0.7, 1),
+                        0.5 * ray.dir.unit_vector().y + 0.5);
         }
     }
 
@@ -266,7 +271,7 @@ class Camera {
         #pragma omp parallel for schedule(dynamic, thread_chunk_size)
         for (size_t row = 0; row < image_h; ++row) {
             for (size_t col = 0; col < image_w; ++col) {
-
+                
                 /* Shoot `samples_per_pixel` random rays through the current pixel.
                 The average of the resulting colors will be the color for this pixel. */
                 auto pixel_color = RGB::zero();
@@ -314,6 +319,7 @@ class Camera {
     distance. */
     auto& set_camera_direction_towards(const Point3D &p) {
         camera.dir = p - camera.origin;
+        camera_lookat.reset();
         return *this;
     }
     /* Set the camera direction to always be towards the point `p`, no matter where the camera
@@ -384,6 +390,13 @@ class Camera {
         vertical_fov.reset();
         return *this;
     }
+    /* Sets the default background color of the camera to `background_color`. This means that any
+    ray which hits no object in a scene being rendered by this `Camera` will have color equal to
+    `background_color`. */
+    auto& set_background(const RGB &background_color) {
+        background = background_color;
+        return *this;
+    }
 
     /* Prints this `Camera` to the `std::ostream` specified by `os`. */
     void print_to(std::ostream &os) {