Added reflections and timing

Author: pmudry

src/v0_single_threaded/camera.h

@@ -3,6 +3,7 @@
 #include <mutex>
 #include <thread>
 #include <vector>
+#include <atomic>
 
 #pragma once
 
@@ -19,15 +20,15 @@ class Camera
     const int image_height = -1;
     const int image_width = static_cast<int>(aspect_ratio * image_height);
 
-    double vfov = 45.0;                // vertical field of view in degrees
-    point3 lookfrom = point3(0, 1, 3); // Point camera is looking from
-    point3 lookat = point3(0, 0, -1);  // Point camera is looking at
+    double vfov = 35.0;                // vertical field of view in degrees
+    point3 lookfrom = point3(2, 2.5, 3); // Point camera is looking from
+    point3 lookat = point3(-1, 0, -1);  // Point camera is looking at
     vec3 vup = vec3(0, 1, 0);          // Camera-relative "up" direction
 
     int samples_per_pixel = 1;
     const int max_depth = 64; // Maximum ray bounce depth
 
-    int n_rays = 0; // Number of rays traced so far with this cam
+    std::atomic<int> n_rays{0}; // Number of rays traced so far with this cam (thread-safe)
 
     Camera(const point3 &center, const int image_height, const int image_channels, int samples_per_pixel = 1)
         : image_height(image_height), samples_per_pixel(samples_per_pixel), image_channels(image_channels), camera_center(center)
@@ -81,6 +82,18 @@ class Camera
         showProgress(image_height - 1, image_height);
         cout << endl;
     }
+    
+    void renderPixelsParallelWithTiming(const hittable &scene, vector<unsigned char> &image)
+    {
+        auto start_time = std::chrono::high_resolution_clock::now();
+        
+        renderPixelsParallel(scene, image);
+        
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+        
+        cout << "Parallel rendering completed in " << duration.count() << " milliseconds" << endl;
+    }
 
     void renderPixelsParallel(const hittable &scene, vector<unsigned char> &image)
     {
@@ -188,16 +201,21 @@ class Camera
         if(depth <= 0)
             return color(0,0,0); // No more light is gathered
 
-        n_rays++;
+        n_rays.fetch_add(1, std::memory_order_relaxed);
 
         hit_record rec;
 
         if (world.hit(r, interval(0.0001, inf), rec)){  
             // Display only normal          
             // return 0.5 * (rec.normal + color(1, 1, 1));
+                        
+            if (rec.isMirror){
+                vec3 reflected = r.direction() - 2 * dot(r.direction(), rec.normal) * rec.normal;
+                return color(.8, 0, 0) * 0.2 + 0.8 * ray_color(ray(rec.p, unit_vector(reflected)), world, depth - 1);
+            }
 
             auto new_ray = vec3::random_in_hemisphere(rec.normal);
-            return 0.5 * ray_color(ray(rec.p, new_ray), world, depth - 1);
+            return 0.7 * ray_color(ray(rec.p, new_ray), world, depth - 1);
         }
 
         // Le vecteur unit_direction variera entre -1 et +1 en x et y
@@ -229,8 +247,7 @@ class Camera
     {
         const int barWidth = 70;
         static int frame = 0;
-        const char *spinner = "|/-\\";
-        // We add 1 to current to start at 1 instead of 0
+        const char *spinner = "|/-\\";        
         float progress = (float)(current + 1) / total;
         int pos = barWidth * progress;
 

src/v0_single_threaded/hittable.h

@@ -13,6 +13,8 @@ class hit_record
     double t; // The ray distance at the hit point
     bool frontFacing; // True if the ray hits the front face of the object
 
+    bool isMirror = false;
+
     void set_face_normal(const ray &r, const vec3 &outward_normal)
     {
         // Sets the hit record normal vector.

src/v0_single_threaded/main.cc

@@ -151,12 +151,27 @@ scene many_spheres()
 {
     scene s;
 
-    s.add(make_shared<sphere>(point3(0, -500.5, -1), 500));
+    s.add(make_shared<sphere>(point3(0, -1000.5, -1), 1000));
     s.add(make_shared<sphere>(point3(0, 0, 0), .5));
-    s.add(make_shared<sphere>(point3(-1, 1, -1), .8));
 
-    for(int i = 0; i < 10; i++)
-        s.add(make_shared<sphere>(point3(RndGen::random_double(-4, 4), 0, RndGen::random_double(0, -4)), .3));
+    auto leftSphere = make_shared<sphere>(point3(-1, 1, -1), .8);
+    leftSphere.get()->isMirror = true;
+    s.add(leftSphere);
+    
+    for(int i = 0; i < 180; i++){
+        auto obj = make_shared<sphere>(
+            point3(
+                RndGen::random_normal(-2, 2), 
+                RndGen::random_normal(-0.5, 0.4),
+                RndGen::random_normal(-0.5, -4)),
+                .1 + RndGen::random_double(0, 0.2));
+        
+        if(RndGen::random_double() < 0.3){
+            obj.get()-> isMirror = true;
+        }
+
+        s.add(obj);
+    }
 
     return s;
 }
@@ -165,7 +180,7 @@ scene single_cube()
 {
     scene s;
 
-    s.add(make_shared<sphere>(point3(0, -500.5, -1), 500));
+    s.add(make_shared<sphere>(point3(0, -1000.5, -1), 1000));
     s.add(make_shared<sphere>(point3(-1, 1, -1), .5));
     auto rotatedCube = make_shared<cube>(point3(0, 0, -1), 1, vec3(0, 45, 0));
     s.add(rotatedCube);
@@ -174,37 +189,28 @@ scene single_cube()
 
 int main()
 {
-    vec3 v1(0.2, 0.2, 0.2);
-    cout << v1 << ": " << v1.length_squared() <<endl;
-    auto l = v1.length_squared();
-
-    // normalizing the vector
-    v1 = unit_vector(v1);
+    const int samples_per_pixel = 64;
 
-    cout << v1 / sqrt(l) << ": " << v1.length_squared() <<endl;
+    Camera c(vec3(0, 0, 0), 1080, channels, samples_per_pixel);
 
-    const int samples_per_pixel = 32;
-    Camera c(vec3(0, 0, 0), 720, channels, samples_per_pixel);
     image_width = c.image_width;
     image_height = c.image_height;
 
     vector<unsigned char> image(c.image_width * c.image_height * channels);
 
-    // scene.add(make_shared<sphere>(point3(0, 0, -1), .5));
-
-    std::cout << "🖼️ resolution: " << c.image_width << " x " << c.image_height << " pixels" << std::endl;
+    std::cout << "Rendering at resolution: " << c.image_width << " x " << c.image_height << " pixels" << std::endl;
 
     // Create a new scene for this frame
     int i = 0;
 
-    RndGen::set_seed(12);
+    RndGen::set_seed(123);
 
     scene s = many_spheres();
     //scene s = single_cube();
 
     // frameScene.add(rotatedCube);
     vector<unsigned char> localImage(image.size());
-    c.renderPixelsParallel(s, localImage);
+    c.renderPixelsParallelWithTiming(s, localImage);
     dumpImageToFile(localImage, "res/output" + to_string(i) + ".png");
 
     // std::function<void(int)> renderFrame = [&](int i)

src/v0_single_threaded/rnd_gen.h

@@ -23,16 +23,16 @@ class RndGen {
         return distribution(get_rng());
     }
 
-    static double random_double(double min, double max) {
-        return random_double() * (max - min) + min;
-    }
-
     static double random_normal() {
         // Returns a random real from standard normal distribution (mean=0, stddev=1).
         static thread_local std::normal_distribution<double> dis(0.0, 1.0);
         return dis(get_rng());
     }
 
+    static double random_double(double min, double max) {
+        return random_double() * (max - min) + min;
+    }
+
     static double random_normal(double mean, double stddev) {
         // Returns a random real from normal distribution with given mean and standard deviation.
         normal_distribution<double> dis(mean, stddev);

src/v0_single_threaded/sphere.h

@@ -5,11 +5,9 @@
 
 class sphere : public hittable
 {
-public:
+public:    
     sphere(const point3 &center, double radius) : center(center), radius(std::fmax(0, radius)) {}
 
-    void setMirror(bool mirror) { isMirror = mirror; }
-
     bool isMirror = false;
 
     /**
@@ -61,6 +59,7 @@ class sphere : public hittable
         rec.t = root;
         rec.p = r.at(rec.t);
         rec.normal = (rec.p - center) / radius;
+        rec.isMirror = isMirror;
 
         return true;
     }