feat: create final render

README.md

@@ -1,5 +1,8 @@
 # Ray Tracing in One Weekend
 
+![Final render](./image.png)
+_P.S. This took 2h+ for my poor laptop to render T-T_
+
 ## Quickstart
 
 ```shell
@@ -9,4 +12,4 @@ sxiv image.ppm
 ```
 
 ## Resources
-* ["Ray Tracing in One Weekend" book](https://raytracing.github.io/books/RayTracingInOneWeekend.html)
+* [_Ray Tracing in One Weekend_](https://raytracing.github.io/books/RayTracingInOneWeekend.html)

camera.h

@@ -0,0 +1,54 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include "rtweekend.h"
+#include "vec3.h"
+#include "ray.h"
+
+class camera {
+	public:
+		camera(
+				point3 lookfrom,
+				point3 lookat,
+				vec3 vup,
+				double vfov, // vertical field-of-view in degrees,
+				double aspect_ratio,
+				double aperture,
+				double focus_dist
+		) {
+			auto theta = degrees_to_radians(vfov);
+			auto h = tan(theta/2);
+			auto viewport_height = 2.0 * h;
+			auto viewport_width = aspect_ratio * viewport_height;
+
+			w = unit_vector(lookfrom - lookat);
+			u = unit_vector(cross(vup, w));
+			v = cross(w, u);
+
+			origin = lookfrom;
+			horizontal = focus_dist * viewport_width * u;
+			vertical = focus_dist * viewport_height * v;
+			lower_left_corner = origin - horizontal/2 - vertical/2 - focus_dist*w;
+
+			lens_radius = aperture/2;
+		}
+
+		ray get_ray(double s, double t) const {
+			vec3 rd = lens_radius * random_in_unit_sphere();
+			vec3 offset = u* rd.x() + v * rd.y();
+			return ray(
+				origin + offset,
+				lower_left_corner + s*horizontal + t*vertical - origin - offset
+			);
+		}
+
+	private:
+		point3 origin;
+		point3 lower_left_corner;
+		vec3 horizontal;
+		vec3 vertical;
+		vec3 u, v, w;
+		double lens_radius;
+};
+
+#endif

color.h

@@ -1,15 +1,26 @@
 #ifndef COLOR_H
 #define COLOR_H
 
+#include "rtweekend.h"
 #include "vec3.h"
 
 #include <iostream>
 
-void write_color(std::ostream &out, color pixel_color) {
+void write_color(std::ostream &out, color pixel_color, int samples_per_pixel) {
+	auto r = pixel_color.x();
+	auto g = pixel_color.y();
+	auto b = pixel_color.z();
+
+	// Divide the color by the number of samples and gamma-correct for gamma=2.0
+	auto scale = 1.0 / samples_per_pixel;
+	r = sqrt(scale * r);
+	g = sqrt(scale * g);
+	b = sqrt(scale * b);
+
 	// Write the translated [0,255] value of each color component
-	out << static_cast<int>(255.999 * pixel_color.x()) << " "
-			<< static_cast<int>(255.999 * pixel_color.y()) << " "
-			<< static_cast<int>(255.999 * pixel_color.z()) << "\n";
+	out << static_cast<int>(256 * clamp(r, 0.0, 0.999)) << " "
+			<< static_cast<int>(256 * clamp(g, 0.0, 0.999)) << " "
+			<< static_cast<int>(256 * clamp(b, 0.0, 0.999)) << "\n";
 }
 
 #endif

hittable.h

@@ -0,0 +1,27 @@
+#ifndef HITTABLE_H
+#define HITTABLE_H
+
+#include "rtweekend.h"
+#include "ray.h"
+
+class material;
+
+struct hit_record {
+	point3 p;
+	vec3 normal;
+	shared_ptr<material> mat_ptr;
+	double t;
+	bool front_face;
+
+	inline void set_face_normal(const ray& r, const vec3& outward_normal) {
+		front_face = dot(r.direction(), outward_normal) < 0;
+		normal = front_face ? outward_normal : -outward_normal;
+	}
+};
+
+class hittable {
+	public:
+		virtual bool hit(const ray& r, double t_min, double t_max, hit_record& hit) const = 0;
+};
+
+#endif

hittable_list.h

@@ -0,0 +1,43 @@
+#ifndef HITTABLE_LIST_H
+#define HITTABLE_LIST_H
+
+#include "hittable.h"
+
+#include <memory>
+#include <vector>
+
+using std::shared_ptr;
+using std::make_shared;
+
+class hittable_list : public hittable {
+	public:
+		hittable_list() {}
+		hittable_list(shared_ptr<hittable> object) { add(object); }
+
+		void clear() { objects.clear(); }
+		void add(shared_ptr<hittable> object) { objects.push_back(object); }
+
+		virtual bool hit(
+				const ray& r, double t_min, double t_max, hit_record& rec) const override;
+
+	public:
+		std::vector<shared_ptr<hittable>> objects;
+};
+
+bool hittable_list::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
+	hit_record temp_rec;
+	bool hit_anything = false;
+	auto closest_so_far = t_max;
+
+	for (const auto& object : objects) {
+		if (object->hit(r, t_min, closest_so_far, temp_rec)) {
+			hit_anything = true;
+			closest_so_far = temp_rec.t;
+			rec = temp_rec;
+		}
+	}
+
+	return hit_anything;
+}
+
+#endif

main.cc

@@ -1,21 +1,111 @@
+
 #include "color.h"
-#include "vec3.h"
+#include "rtweekend.h"
+#include "hittable_list.h"
+#include "sphere.h"
+#include "camera.h"
+#include "material.h"
 
 #include <iostream>
 
+color ray_color(const ray& r, const hittable& world, int depth) {
+	hit_record rec;
+
+	// If we've exceeded the ray bounce limit, no more light is gathered.
+	if (depth <= 0)
+		return color(0, 0, 0);
+
+	if (world.hit(r, 0.001, infinity, rec)) {
+		ray scattered;
+		color attenuation;
+		if (rec.mat_ptr->scatter(r, rec, attenuation, scattered))
+				return attenuation * ray_color(scattered, world, depth-1);
+		return color(0,0,0);
+	}
+
+	vec3 unit_direction = unit_vector(r.direction());
+	auto t = 0.5*(unit_direction.y() + 1.0);
+	return (1.0 - t)*color(1.0, 1.0, 1.0) + t*color(0.5, 0.7, 1.0);
+}
+
+hittable_list random_scene() {
+	hittable_list world;
+
+	auto ground_material = make_shared<lambertian>(color(0.5, 0.5, 0.5));
+	world.add(make_shared<sphere>(point3(0, -1000, 0), 1000, ground_material));
+
+	for (int a = -11; a < 11; a++) {
+		for (int b = -11; b < 11; b++) {
+			auto choose_mat = random_double();
+			point3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());
+
+			if ((center - point3(4, 0.2, 0)).length() > 0.9) {
+				shared_ptr<material> sphere_material;
+
+				if (choose_mat < 0.8) {
+					// diffuse
+					auto albedo = color::random() * color::random();
+					sphere_material = make_shared<lambertian>(albedo);
+					world.add(make_shared<sphere>(center, 0.2, sphere_material));
+				} else if(choose_mat < 0.95) {
+					// metal
+					auto albedo = color::random(0.5, 1);
+					auto fuzz = random_double(0, 0.5);
+					sphere_material = make_shared<metal>(albedo, fuzz);
+					world.add(make_shared<sphere>(center, 0.2, sphere_material));
+				} else {
+					// glass
+					sphere_material = make_shared<dialectric>(1.5);
+					world.add(make_shared<sphere>(center, 0.2, sphere_material));
+				}
+			}
+		}
+	}
+
+	auto material1 = make_shared<dialectric>(1.5);
+	world.add(make_shared<sphere>(point3(0, 1, 0), 1.0, material1));
+
+	auto material2 = make_shared<lambertian>(color(0.4, 0.2, 0.1));
+	world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));
+
+	auto material3 = make_shared<metal>(color(0.7, 0.6, 0.5), 0.0);
+	world.add(make_shared<sphere>(point3(4, 1, 0), 1.0, material3));
+
+	return world;
+}
+
 int main() {
 	// Image
-	const int image_width = 256;
-	const int image_height = 256;
+	const auto aspect_ratio = 3.0 / 2.0;
+	const int image_width = 1200;
+	const int image_height = static_cast<int>(image_width / aspect_ratio);
+	const int samples_per_pixel = 50;
+	const int max_depth = 50;
+
+	// World
+	hittable_list world = random_scene();
+
+	// Camera
+	point3 lookfrom(13, 2, 3);
+	point3 lookat(0, 0, 0);
+	vec3 vup(0, 1, 0);
+	auto dist_to_focus = 10;
+	auto aperture = 0.1;
+	camera cam(lookfrom, lookat, vup, 20, aspect_ratio, aperture, dist_to_focus);
 
 	// Render
-	std::cout<<"P3\n"<<image_width<<" "<<image_height<<"\n255\n";
+	std::cout<<"P3\n" <<image_width<<" "<<image_height<<"\n255\n";
 	for (int j = image_height-1; j >= 0; --j) {
 		std::cerr<<"\rScanlines remaining: "<<j<<" "<<std::flush;
 		for (int i = 0; i < image_width; ++i) {
-			color pixel_color(double(i) / (image_width-1), double(j) / (image_height-1), 0.25);
-
-			write_color(std::cout, pixel_color);
+			color pixel_color(0, 0, 0);
+			for (int s = 0; s < samples_per_pixel; ++s) {
+				auto u = (i + random_double()) / (image_width-1);
+				auto v = (j + random_double()) / (image_height-1);
+				ray r = cam.get_ray(u, v);
+				pixel_color += ray_color(r, world, max_depth);
+			}
+			write_color(std::cout, pixel_color, samples_per_pixel);
 		}
 	}
 	std::cerr<<"\nDone.\n";

material.h

@@ -0,0 +1,94 @@
+#ifndef MATERIAL_H
+#define MATERIAL_H
+
+#include "hittable.h"
+#include "rtweekend.h"
+#include "vec3.h"
+
+struct hit_record;
+
+class material {
+	public:
+		virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const = 0;
+};
+
+
+class lambertian : public material {
+	public:
+		lambertian(const color& a) : albedo(a) {}
+
+		bool scatter(
+			const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
+		) const override {
+			auto scatter_direction = rec.normal + random_in_hemisphere(rec.normal);
+
+			// Catch degenerate scatter direction
+			if (scatter_direction.near_zero())
+				scatter_direction = rec.normal;
+
+			scattered = ray(rec.p, scatter_direction);
+			attenuation = albedo;
+			return true;
+		}
+
+	public:
+		color albedo;
+};
+
+class metal : public material {
+	public:
+		metal(const color& a, double f) : albedo(a), fuzz(f < 1 ? f : 1) {}
+
+		bool scatter(
+				const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
+		) const override {
+			vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
+			scattered = ray(rec.p, reflected + fuzz*random_in_hemisphere(rec.normal));
+			attenuation = albedo;
+			return (dot(scattered.direction(), rec.normal) > 0);
+		}
+
+	public:
+		color albedo;
+		double fuzz;
+};
+
+class dialectric : public material {
+	public:
+		dialectric(double index_of_refraction): ir(index_of_refraction) {}
+
+		bool scatter(
+			const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
+		) const override {
+			attenuation = color(1.0, 1.0, 1.0);
+			double refraction_ratio = rec.front_face ? (1.0/ir) : ir;
+
+			vec3 unit_direction = unit_vector(r_in.direction());
+			double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
+			double sin_theta = sqrt(1 - cos_theta*cos_theta);
+
+			bool cannot_refract = refraction_ratio * sin_theta > 1.0;
+			vec3 direction;
+			if (cannot_refract || reflectance(cos_theta, refraction_ratio) > random_double())
+				direction = reflect(unit_direction, rec.normal);
+			else
+				direction = refract(unit_direction, rec.normal, refraction_ratio);
+
+			scattered = ray(rec.p, direction);
+			return true;
+		}
+
+
+	public:
+		double ir; // Index of Refraction
+
+	private:
+		static double reflectance(double cosine, double ref_idx) {
+			// Use Schlick's approximation for reflectance
+			auto r0 = (1-ref_idx) /(1+ref_idx);
+			r0 = r0*r0;
+			return r0 + (1-r0)*pow((1 - cosine), 5);
+		}
+};
+
+#endif

ray.h

@@ -0,0 +1,25 @@
+#ifndef RAY_H
+#define RAY_H
+
+#include "vec3.h"
+
+class ray {
+	public:
+		ray() {}
+		ray(const point3& origin, const vec3& direction)
+			: orig(origin), dir(direction)
+		{}
+
+		point3 origin() const { return orig; }
+		vec3 direction() const { return dir; }
+
+		point3 at(double t) const {
+			return orig + t*dir;
+		}
+
+	public:
+		point3 orig;
+		vec3 dir;
+};
+
+#endif

rtweekend.h

@@ -0,0 +1,39 @@
+#ifndef RTWEEKEND_H
+#define RTWEEKEND_H
+
+#include <cmath>
+#include <limits>
+#include <memory>
+#include <cstdlib>
+
+// Usings
+using std::shared_ptr;
+using std::make_shared;
+using std::sqrt;
+
+// Constants
+const double infinity = std::numeric_limits<double>::infinity();
+const double pi = 3.1415926535897932385;
+
+// Utility functions
+inline double degrees_to_radians(double degrees) {
+	return degrees * pi / 180.0;
+}
+
+// Returns a random number between (0,1]
+inline double random_double() {
+	return rand() / (RAND_MAX + 1.0);
+}
+
+inline double clamp(double x, double min, double max) {
+	if (x < min) return min;
+	if (x > max) return max;
+	return x;
+}
+
+// Returns a random number between (min,max]
+inline double random_double(double min, double max) {
+	return min + (max - min) * random_double();
+}
+
+#endif

sphere.h

@@ -0,0 +1,48 @@
+#ifndef SPHERE_H
+#define SPHERE_H
+
+#include "hittable.h"
+#include "vec3.h"
+
+class sphere : public hittable {
+	public:
+		sphere() {}
+		sphere(point3 cen, double r, shared_ptr<material> m) : center(cen), radius(r), mat_ptr(m) {};
+
+		virtual bool hit(
+				const ray& r, double t_min, double t_max, hit_record& rec) const override;
+
+	public:
+		point3 center;
+		double radius;
+		shared_ptr<material> mat_ptr;
+};
+
+bool sphere::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
+	vec3 oc = r.origin() - center;
+	auto a = r.direction().length_squared();
+	auto half_b = dot(oc, r.direction());
+	auto c = oc.length_squared() - radius*radius;
+
+	auto discriminant = half_b*half_b - a*c;
+	if (discriminant < 0) return false;
+	auto sqrtd = sqrt(discriminant);
+
+	// Find the nearest root that lies in the acceptable range.
+	auto root = (-half_b - sqrtd) / a;
+	if (root < t_min || t_max < root) {
+		root = (-half_b + sqrtd) / a;
+		if (root < t_min || t_max < root)
+			return false;
+	}
+
+	rec.t = root;
+	rec.p = r.at(rec.t);
+	vec3 outward_normal = (rec.p - center) / radius;
+	rec.set_face_normal(r, outward_normal);
+	rec.mat_ptr = mat_ptr;
+
+	return true;
+}
+
+#endif

vec3.h

@@ -4,6 +4,8 @@
 #include <cmath>
 #include <iostream>
 
+#include "rtweekend.h"
+
 using std::sqrt;
 
 class vec3 {
@@ -45,6 +47,19 @@ class vec3 {
 			return e[0]*e[0] + e[1]*e[1] + e[2]*e[2];
 		}
 
+		inline static vec3 random() {
+			return vec3(random_double(), random_double(), random_double());
+		}
+
+		inline static vec3 random(double min, double max) {
+			return vec3(random_double(min, max), random_double(min, max), random_double(min, max));
+		}
+
+		bool near_zero() const {
+			auto s = 1e-8;
+			return fabs(e[0]) < s && fabs(e[1]) < s && fabs(e[2]) < s;
+		}
+
 	public:
 		double e[3];
 };
@@ -95,8 +110,39 @@ inline vec3 cross(const vec3 &u, const vec3 &v) {
 	            u.e[0] * v.e[1] - u.e[1] * v.e[0]);
 }
 
+vec3 random_in_unit_sphere() {
+	while(true) {
+		auto p = vec3::random(-1, 1);
+		if (p.length_squared() >= 1) continue;
+		return p;
+	}
+}
+
 inline vec3 unit_vector(vec3 v) {
 	return v / v.length();
 }
 
+vec3 random_unit_vector() {
+	return unit_vector(random_in_unit_sphere());
+}
+
+vec3 random_in_hemisphere(const vec3& normal) {
+	vec3 in_unit_sphere = random_in_unit_sphere();
+	if (dot(in_unit_sphere, normal) > 0.0) // In thesame hemisphere as the normal
+		return in_unit_sphere;
+	else
+		return -in_unit_sphere;
+}
+
+vec3 reflect(const vec3& v, const vec3& n) {
+	return v - 2*dot(v,n)*n;
+}
+
+vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat) {
+	auto cos_theta = fmin(dot(-uv, n), 1.0);
+	vec3 r_out_perp = etai_over_etat * (uv + cos_theta*n);
+	vec3 r_out_parrallel = -sqrt(fabs(1.0 - r_out_perp.length_squared())) * n;
+	return r_out_perp + r_out_parrallel;
+}
+
 #endif