Address review comments

Author: Luc Forget

README.md

@@ -91,9 +91,16 @@ This creates the executable.
 
 Now you can run the path tracer with:
 ```sh
-time RT_SYCL/sycl-rt >! result.ppm
+time ./sycl-rt 800 480 50 100
 ```
-This results in the image ``result.ppm`` produced by the path tracer.
+This results in the image ``out.png`` produced by the path tracer.
+
+Parameters to the executable are 
+
++ The output image width (here 800)
++ The output image height (here 480)
++ The maximum bouncing depth of the ray (here 50)
++ The number of samples per pixel (here 100)
 
 
 ## Bibliography

include/rtweekend.hpp

@@ -38,14 +38,13 @@ inline real_t degrees_to_radians(real_t degrees) {
   return degrees * pi / 180.0f;
 }
 
-uint32_t toseed(vec const& val) {
-  uint32_t x, y, z;
-  std::memcpy(&x, &val.x(), sizeof(uint32_t));
-  std::memcpy(&y, &val.y(), sizeof(uint32_t));
-  std::memcpy(&z, &val.z(), sizeof(uint32_t));
-  return x * x * y * y * z * z;
-}
+/**
+  @brief hash two vector using coordinates low bits
 
+  @param val1 first vector
+  @param val2 second vector
+  @return uint32_t 
+ */
 uint32_t toseed(vec const& val1, vec const& val2) {
   uint32_t x1, y1, z1, x2, y2, z2;
   std::memcpy(&x1, &val1.x(), sizeof(uint32_t));
@@ -55,12 +54,12 @@ uint32_t toseed(vec const& val1, vec const& val2) {
   std::memcpy(&y2, &val2.y(), sizeof(uint32_t));
   std::memcpy(&z2, &val2.z(), sizeof(uint32_t));
   uint32_t shifted1 = x1 << 26;
-  uint32_t shifted2 = (x2 & 63) << 21;
+  uint32_t shifted2 = (x2 & 31) << 21;
   uint32_t shifted3 = (y1 & 63) << 15;
-  uint32_t shifted4 = (y2 & 63) << 10;
-  uint32_t shifted5 = (z1 & 63) << 5;
-  uint32_t shifted6 = (z2 & 63);
-  return shifted1 ^ shifted2 ^ shifted3 ^ shifted4 ^ shifted5 ^ shifted6;
+  uint32_t shifted4 = (y2 & 31) << 10;
+  uint32_t shifted5 = (z1 & 31) << 5;
+  uint32_t shifted6 = (z2 & 31);
+  return shifted1 | shifted2 | shifted3 | shifted4 | shifted5 | shifted6;
 }
 
 class LocalPseudoRNG {

src/main.cpp

@@ -1,11 +1,13 @@
 #include "sycl.hpp"
+#include "xorshift.hpp"
 #include <algorithm>
 #include <chrono>
 #include <cstdint>
 #include <ctime>
 #include <iostream>
 #include <iterator>
 #include <math.h>
+#include <string>
 #include <thread>
 #include <vector>
 
@@ -59,8 +61,9 @@ void save_image_png(int width, int height, sycl::buffer<color, 2>& fb) {
 }
 
 int main(int argc, char* argv[]) {
-  if (argc != 5) {
-    std::cerr << "Usage: sycl-rt OUT_WIDTH OUT_HEIGHT DEPTH SAMPLES"
+  if (argc < 5 || argc > 7) {
+    std::cerr << "Usage: sycl-rt OUT_WIDTH OUT_HEIGHT DEPTH SAMPLES "
+                 "[SPHERE_INC [RAND_SEED]]"
               << std::endl;
     return -1;
   }
@@ -69,6 +72,14 @@ int main(int argc, char* argv[]) {
   auto height = std::stoi({ argv[2] });
   auto depth = std::stoi({ argv[3] });
   auto samples = std::stoi({ argv[4] });
+  int sphere_inc = 1;
+  if (argc >= 6)
+    sphere_inc = std::stoi({ argv[5] });
+
+  auto rand_seed = xorshift<>::initial_state;
+
+  if (argc >= 7)
+    rand_seed = std::stoi({ argv[6] });
 
   /// Graphical objects
   std::vector<hittable_t> hittables;
@@ -80,10 +91,10 @@ int main(int argc, char* argv[]) {
   hittables.emplace_back(sphere(point { 0, -1000, 0 }, 1000, m));
   t = checker_texture(color { 0.9f, 0.9f, 0.9f }, color { 0.4f, 0.2f, 0.1f });
 
-  LocalPseudoRNG rng{static_cast<uint32_t>(std::time(nullptr))};
+  LocalPseudoRNG rng{rand_seed};
 
-  for (int a = -11; a < 11; a++) {
-    for (int b = -11; b < 11; b++) {
+  for (int a = -11; a < 11; a += sphere_inc) {
+    for (int b = -11; b < 11; b += sphere_inc) {
       auto choose_mat = rng.real();
       // Spheres are placed at a point randomly displaced from a,b
       point center(a + 0.9f * rng.real(), 0.2f, b + 0.9f * rng.real());