raytracing in one weekend: final

Author: Marcythm

.gitignore

@@ -1,3 +1,2 @@
 .DS_Store
-/**/makefile
 /.vscode

src/config.hpp

@@ -197,10 +197,10 @@ enum class diffuse_render_method: bool {
 namespace constants {
 
 	// Image
-	constexpr f64 aspect_ratio = 16.0 / 9.0;
-	constexpr i32 image_width = 400;
+	constexpr f64 aspect_ratio = 3.0 / 2.0; // 16.0 / 9.0;
+	constexpr i32 image_width = 1200; // 400;
 	constexpr i32 image_height = static_cast<i32>(image_width / aspect_ratio);
-	constexpr i32 samples_per_pixel = 100;
+	constexpr i32 samples_per_pixel = 500; // 100;
 	constexpr i32 max_depth = 50;
 	constexpr f64 GAMMA = 2;
 

src/hittable.hpp src/hittable/hittable.hppsrc/hittable.hpp renamed to src/hittable/hittable.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "config.hpp"
+#include "ray.hpp"
+#include "hittable.hpp"
+
+class HittableList: public Hittable {
+    Vec<ptr<Hittable>> objects;
+
+public:
+    HittableList() = default;
+    ~HittableList() = default;
+
+    auto clear() -> void { objects.clear(); }
+    template <typename T>
+    auto push(const T &obj) -> void {
+        if constexpr (std::is_convertible_v<T, ptr<Hittable>>)
+            objects.push_back(obj);
+        else {
+            static_assert(std::is_base_of_v<Hittable, T>, "try to add an object which is not hittable into a hittable list");
+            objects.emplace_back(std::make_shared<T>(obj));
+        }
+    }
+
+    auto hit(const Ray &ray, const f64 t_min, const f64 t_max) const -> std::optional<HitRecord> override;
+};

src/hittablelist.cpp src/hittable/hittablelist.cppsrc/hittablelist.cpp renamed to src/hittable/hittablelist.cpp

@@ -11,49 +11,81 @@
 #include "metal.hpp"
 #include "dielectric.hpp"
 
+auto random_scene() -> HittableList {
+	HittableList scene;
+
+	const auto ground_material = std::make_shared<Lambertian>(RGB(0.5, 0.5, 0.5));
+	scene.push(Sphere(p3d(0.0, -1000.0, 0.0), 1000.0, ground_material));
+
+	for (i32 a = -11; a < 11; ++a)
+		for (i32 b = -11; b < 11; ++b) {
+			const p3d center(a + 0.9 * random_f64(), 0.2, b + 0.9 * random_f64());
+
+			if ((center - p3d(4.0, 0.2, 0.0)).length() > 0.9) {
+				const f64 which_material = random_f64();
+
+				if (which_material < 0.8) {
+					// diffuse
+					const auto albedo = RGB::random() * RGB::random();
+					const auto sphere_material = std::make_shared<Lambertian>(albedo);
+					scene.push(Sphere(center, 0.2, sphere_material));
+				} else if (which_material < 0.95) {
+					// metal
+					const auto albedo = RGB::random(0.5, 1.0);
+					const auto fuzz = random_f64(0.0, 0.5);
+					const auto sphere_material = std::make_shared<Metal>(albedo, fuzz);
+					scene.push(Sphere(center, 0.2, sphere_material));
+				} else {
+					// glass
+					const auto sphere_material = std::make_shared<Dielectric>(1.5);
+					scene.push(Sphere(center, 0.2, sphere_material));
+				}
+			}
+		}
+
+	const auto material1 = std::make_shared<Dielectric>(1.5);
+	scene.push(Sphere(p3d(0.0, 1.0, 0.0), 1.0, material1));
+
+	const auto material2 = std::make_shared<Lambertian>(RGB(0.4, 0.2, 0.1));
+	scene.push(Sphere(p3d(-4.0, 1.0, 0.0), 1.0, material2));
+
+	const auto material3 = std::make_shared<Metal>(RGB(0.7, 0.6, 0.5), 0.0);
+	scene.push(Sphere(p3d(4.0, 1.0, 0.0), 1.0, material3));
+
+	return scene;
+}
+
 auto main() -> i32 {
-	// World
-	const auto material_ground = std::make_shared<Lambertian>(RGB(0.8, 0.8, 0.0));
-	const auto material_center = std::make_shared<Lambertian>(RGB(0.1, 0.2, 0.5));
-	const auto material_left   = std::make_shared<Dielectric>(1.5);
-	const auto material_right  = std::make_shared<Metal>(RGB(0.8, 0.6, 0.2), 0.0);
-
-	HittableList world;
-	world.push(std::make_shared<Sphere>(p3d( 0.0, -100.5, -1.0), 100.0, material_ground));
-	world.push(std::make_shared<Sphere>(p3d( 0.0,    0.0, -1.0),   0.5, material_center));
-	world.push(std::make_shared<Sphere>(p3d(-1.0,    0.0, -1.0),   0.5, material_left));
-	world.push(std::make_shared<Sphere>(p3d(-1.0,    0.0, -1.0), -0.45, material_left));
-	world.push(std::make_shared<Sphere>(p3d( 1.0,    0.0, -1.0),   0.5, material_right));
+	// Scene
+	const auto scene = random_scene();
 
 	// Camera
-	const p3d lookfrom(3, 3, 2);
-	const p3d lookat(0, 0, -1);
-	const Vec3 viewup(0, 1, 0);
-	const f64 focus_distance = (lookfrom - lookat).length();
-	const f64 aperture = 2.0;
+	const p3d lookfrom(13.0, 2.0, 3.0);
+	const p3d lookat(0.0, 0.0, 0.0);
+	const Vec3 viewup(0.0, 1.0, 0.0);
+	const f64 focus_distance = 10.0;
+	const f64 aperture = 0.1;
 
-	const Camera camera(lookfrom, lookat, viewup, 20, constants::aspect_ratio, aperture, focus_distance);
-	// const Camera camera(p3d(-2, 2, 1), p3d(0, 0, -1), Vec3(0, 1, 0), 90, constants::aspect_ratio);
+	const Camera camera(lookfrom, lookat, viewup, 20.0, constants::aspect_ratio, aperture, focus_distance);
 
 	// Render
 	std::cout.tie(0);
 	std::cout << "P3\n";
 	std::cout << constants::image_width << ' ' << constants::image_height << '\n';
 	std::cout << "255\n";
 
-
 	for (i32 j = constants::image_height - 1; j >= 0; --j) {
-		std::cerr << "Scanlines remaining: " << j << '\n' << std::flush;
+		fprintf(stderr, "Rendering: %d lines remaining\n", j);
 		for (i32 i = 0; i < constants::image_width; ++i) {
-			RGB pixel_color(0, 0, 0);
+			RGB pixel_color(0.0, 0.0, 0.0);
 			for (i32 s = 0; s < constants::samples_per_pixel; ++s) {
 				const f64 u = (i + random_f64()) / (constants::image_width - 1);
 				const f64 v = (j + random_f64()) / (constants::image_height - 1);
-				pixel_color += camera.get_ray(u, v).color(world, constants::max_depth);
+				pixel_color += camera.get_ray(u, v).color(scene, constants::max_depth);
 			}
 			std::cout << pixel_color << '\n';
 		}
 	}
-	std::cerr << "\nDone.\n";
+	fprintf(stderr, "\nDone.\n");
 	return 0;
 }

src/hittable/hittablelist.hpp

@@ -0,0 +1,2 @@
+all: *.hpp *.cpp
+	clang++ -Wall -Wextra -std=c++2a -I. -Iutilities -Ihittable -Imaterial -O2 *.cpp hittable/*.cpp -o main