Antialiasing

rtiww/CMakeLists.txt

@@ -8,4 +8,5 @@ add_executable(rtiww src/main.cpp
   src/color.h
   src/hittable.h src/hittable_list.h
   src/sphere.h
+  src/camera.h
   src/rtweekend.h)

rtiww/src/camera.h

@@ -0,0 +1,33 @@
+#ifndef CAMERA_H_
+#define CAMERA_H_
+
+#include "rtweekend.h"
+
+class camera {
+public:
+  camera() {
+    auto aspect_ratio = 16.0 / 9.0;
+    auto viewport_height = 2.0;
+    auto viewport_width = aspect_ratio * viewport_height;
+    auto focal_length = 1.0;
+
+    origin = point3(0, 0, 0);
+    horizontal = vec3(viewport_width, 0.0, 0.0);
+    vertical = vec3(0.0, viewport_height, 0.0);
+    lower_left_corner =
+        origin - horizontal / 2 - vertical / 2 - vec3(0, 0, focal_length);
+  }
+
+  ray get_ray(double u, double v) const {
+    return ray(origin,
+               lower_left_corner + u * horizontal + v * vertical - origin);
+  }
+
+private:
+  point3 origin;
+  point3 lower_left_corner;
+  vec3 horizontal;
+  vec3 vertical;
+};
+
+#endif // CAMERA_H_

rtiww/src/color.h

@@ -1,14 +1,24 @@
 #ifndef RTIWW_COLOR_H
 #define RTIWW_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) {
-    out << static_cast<int>(255.999 * pixel_color.x()) << ' '
+  auto r = pixel_color.x();
-        << static_cast<int>(255.999 * pixel_color.y()) << ' '
+  auto g = pixel_color.y();
-        << static_cast<int>(255.999 * pixel_color.z()) << '\n';
+  auto b = pixel_color.z();
+
+  auto scale = 1.0 / samples_per_pixel;
+  r *= scale;
+  g *= scale;
+  b *= scale;
+
+  out << static_cast<int>(255.999 * clamp(r, 0.0, 0.999)) << ' '
+      << static_cast<int>(255.999 * clamp(g, 0.0, 0.999)) << ' '
+      << static_cast<int>(255.999 * clamp(b, 0.0, 0.999)) << '\n';
 }
 
-#endif //RTIWW_COLOR_H
+#endif // RTIWW_COLOR_H

rtiww/src/main.cpp

@@ -1,3 +1,4 @@
+#include "camera.h"
 #include "hittable.h"
 #include "rtweekend.h"
 
@@ -7,13 +8,13 @@
 
 #include <iostream>
 
-color ray_color(const ray &r, const hittable& world) {
+color ray_color(const ray &r, const hittable &world) {
   hit_record rec;
-    if(world.hit(r, 0, infinity, rec)) {
+  if (world.hit(r, 0, infinity, rec)) {
-        return 0.5 * (rec.normal + color(1,1,1));
+    return 0.5 * (rec.normal + color(1, 1, 1));
   }
   vec3 unit_direction = unit_vector(r.direction());
-    auto t = 0.5*(unit_direction.y() + 1.0);
+  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);
 }
 
@@ -23,21 +24,15 @@ int main() {
   const auto aspect_ratio = 16.0 / 9.0;
   const int image_width = 400;
   const int image_height = static_cast<int>(image_width / aspect_ratio);
+  const int samples_per_pixel = 100;
 
   // World
   hittable_list world;
-    world.add(make_shared<sphere>(point3(0,0,-1), 0.5));
+  world.add(make_shared<sphere>(point3(0, 0, -1), 0.5));
-    world.add(make_shared<sphere>(point3(0,-100.5,-1), 100));
+  world.add(make_shared<sphere>(point3(0, -100.5, -1), 100));
 
   // Camera
-    auto viewport_height = 2.0;
+  camera cam;
-    auto viewport_width = aspect_ratio * viewport_height;
-    auto focal_length = 1.0;
-
-    auto origin = point3(0, 0, 0);
-    auto horizontal = vec3(viewport_width, 0, 0);
-    auto vertical = vec3(0, viewport_height, 0);
-    auto lower_left_corner = origin - horizontal / 2 - vertical / 2 - vec3(0, 0, focal_length);
 
   // Render
   std::cout << "P3\n" << image_width << ' ' << image_height << "\n255\n";
@@ -45,12 +40,15 @@ int main() {
   for (int j = image_height - 1; j >= 0; --j) {
     std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
     for (int i = 0; i < image_width; ++i) {
-            auto u = double(i) / (image_width - 1);
+      color pixel_color(0, 0, 0);
-            auto v = double(j) / (image_height - 1);
+      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(origin, lower_left_corner + u * horizontal + v * vertical - origin);
+        ray r = cam.get_ray(u, v);
-            color pixel_color = ray_color(r, world);
+        pixel_color += ray_color(r, world);
-            write_color(std::cout, pixel_color);
+      }
+      write_color(std::cout, pixel_color, samples_per_pixel);
     }
   }
 

rtiww/src/rtweekend.h

@@ -5,8 +5,8 @@
 #include <limits>
 #include <memory>
 
-using std::shared_ptr;
 using std::make_shared;
+using std::shared_ptr;
 using std::sqrt;
 
 const double infinity = std::numeric_limits<double>::infinity();
@@ -23,7 +23,15 @@ inline double random_double() {
 
 inline double random_double(double min, double max) {
   // Returns a random real in [min, max).
-    return min + (max-min)*random_double();
+  return min + (max - min) * random_double();
+}
+
+inline double clamp(double x, double min, double max) {
+  if (x < min)
+    return min;
+  if (x > max)
+    return max;
+  return x;
 }
 
 #include "ray.h"