wip

README.md

@@ -7,22 +7,3 @@ Originally based on https://raytracing.github.io/
 Original repository at https://github.com/ktyldev/flark
 
 https://www.linuxhowtos.org/C_C++/socket.htm
-
-## todo
-
-* [x] waits for connection
-* [x] send a message to the client
-* [x] move core rendering out of main.cpp
-* [x] combine 'hittable' 'hittable_list' and 'scene' in 'world'
-* [x] send rendered image data to client
-* [x] form image file on client
-* [x] extract netcode from main
-* [ ] specify protocol format
-* [ ] receive imaging command
-* [x] render image
-* [x] send image data
-* [ ] send image data using udp
-* [ ] send telemetry
-* [ ] compress image before sending
-
-

include/camera.h

@@ -1,13 +1,11 @@
 #pragma once
 
-#include "math.h"
+#include "rtweekend.h"
-#include "vec3.h"
-#include "ray.h"
 #include "image.h"
 
 class camera
 {
-public:
+    public:
         camera(
             point3  lookfrom,
             point3  lookat,
@@ -15,11 +13,36 @@ public:
             double  vfov,   // vertical field of view in degrees
             double  aspect_ratio,
             double  aperture,
-        double  focus_dist);
+            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;
 
-    ray get_ray(double s, double t) const; 
+            w_ = unit_vector(lookfrom - lookat);
+            u_ = unit_vector(cross(vup, w_));
+            v_ = cross(w_, u_);
 
-private:
+            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_disk();
+            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_;

include/colour.h

@@ -1,7 +1,6 @@
 #pragma once
 
-#include "error.h"
+#include "rtweekend.h"
-#include "vec3.h"
 
 // for writing to stdout
 #include <iostream>
@@ -9,21 +8,59 @@
 // for writing to socket
 #include <unistd.h>
 
-class colour : public vec3
-{
-    using vec3::vec3;
-
-public:
-    friend colour operator*(const colour& u, const colour& v);
-    friend colour lerp(const colour& a, const colour& b, double t);
-
-    colour correct_gamma(int samples);
-
-    friend void write_colour_to_socket(int sockfd, colour pixel_colour, int samples_per_pixel);
-    friend void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_per_pixel);
-    friend int format_component(double component);
-};
-
 const colour pink(254.0/255.0, 226.0/255.0, 170.0/255.0);
 const colour grey(0.133, 0.133, 0.133);
 
+void correct_gamma(colour& pixel_colour, int samples)
+{
+    double r = pixel_colour.x();
+    double g = pixel_colour.y();
+    double b = pixel_colour.z();
+
+    // divide the colour total by the number of samples and gamma-correct for gamma=2.0
+    auto scale = 1.0 / samples;
+    r = sqrt(scale * r);
+    g = sqrt(scale * g);
+    b = sqrt(scale * b);
+
+    pixel_colour = colour(r, g, b);
+}
+
+void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_per_pixel)
+{
+    correct_gamma(pixel_colour, samples_per_pixel);
+
+    auto r = pixel_colour.x();
+    auto g = pixel_colour.y();
+    auto b = pixel_colour.z();
+    
+    // write the translated [0,255] value of each colour component.
+    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';
+}
+
+int format_component(double component)
+{
+    return int(256 * clamp(component, 0.0, 0.999));
+}
+
+void write_colour_to_socket(int sockfd, colour pixel_colour, int samples_per_pixel)
+{
+    correct_gamma(pixel_colour, samples_per_pixel);
+
+    int r = format_component(pixel_colour.x());
+    int g = format_component(pixel_colour.y());
+    int b = format_component(pixel_colour.z());
+
+    // pack values
+    int len = 3;
+    char s[len];
+    sprintf(s, "%c%c%c", r, g, b);
+
+    int written = write(sockfd, s, len);
+    if (written < 0)
+    {
+        error("ERROR writing colour to socket");
+    }
+}

include/error.h

@@ -1,5 +1,7 @@
-#pragma once
-
 #include <iostream>
 
-void error(const char* message);
+void error(const char* message)
+{
+    perror(message);
+    exit(1);
+}

include/hit_record.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <cmath>
-#include <cstdlib>
-#include <limits>
-#include <memory>
-
-class material;
-
-struct hit_record
-{
-    point3                      p;
-    vec3                        normal;
-    std::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;
-    }
-};

include/hittable.h

@@ -1,10 +1,27 @@
 #pragma once
 
+#include "rtweekend.h"
 #include "ray.h"
-#include "hit_record.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:
+    public:
         virtual bool hit(const ray& r, double tMin, double tMax, hit_record& rec) const = 0;
 };

include/hittable_list.h

@@ -20,3 +20,21 @@ class hittable_list : public hittable
         std::vector<std::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;
+}

include/material.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include "rtweekend.h"
 #include "hittable.h"
-#include "hit_record.h"
 
 class material
 {
@@ -13,6 +13,13 @@ class material
             ray& scattered) const = 0;
 };
 
+double schlick(double cosine, double refraction_index)
+{
+    auto r0 = (1-refraction_index) / (1+refraction_index);
+    r0 = r0*r0;
+    return r0 + (1-r0)*pow(1-cosine, 5);
+}
+
 class lambertian : public material
 {
     public:
@@ -24,7 +31,7 @@ class lambertian : public material
             colour& attenuation, 
             ray& scattered) const 
         {
-            vec3 scatter_direction = rec.normal + vec3::random_unit_vector();
+            vec3 scatter_direction = rec.normal + random_unit_vector();
             scattered = ray(rec.p, scatter_direction);
             attenuation = albedo_;
             return true;
@@ -47,8 +54,8 @@ class metal : public material
         colour& attenuation, 
         ray& scattered) const 
     {
-        vec3 reflected = reflect(normalize(r_in.direction()), rec.normal);
+        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
-        scattered = ray(rec.p, reflected + fuzz_ * vec3::random_in_unit_sphere());
+        scattered = ray(rec.p, reflected + fuzz_*random_in_unit_sphere());
         attenuation = albedo_;
         return dot(scattered.direction(), rec.normal) > 0;
     }
@@ -72,7 +79,7 @@ class dielectric : public material
         attenuation = colour(1.0,1.0,1.0);
         double etai_over_etat = rec.front_face ? (1.0 / refraction_index_) : refraction_index_;
 
-        vec3 unit_direction = normalize(r_in.direction());
+        vec3 unit_direction = unit_vector(r_in.direction());
 
         double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
         double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
@@ -84,7 +91,7 @@ class dielectric : public material
         }
 
         double reflect_prob = schlick(cos_theta, etai_over_etat);
-        if (math::random_double() < reflect_prob)
+        if (random_double() < reflect_prob)
         {
             vec3 reflected = reflect(unit_direction, rec.normal);
             scattered = ray(rec.p, reflected);
@@ -99,11 +106,4 @@ class dielectric : public material
 
     private:
         double refraction_index_;
-
-        double schlick(double cosine, double refraction_index) const
-        {
-            auto r0 = (1-refraction_index) / (1+refraction_index);
-            r0 = r0*r0;
-            return r0 + (1-r0)*pow(1-cosine, 5);
-        }
 };

include/math.h

@@ -2,14 +2,29 @@
 
 #include <cmath>
 
-class math
+const double infinity = std::numeric_limits<double>::infinity();
-{
+const double pi = 3.1415926535897932385;
-public:
-    static constexpr double infinity = std::numeric_limits<double>::infinity();
-    static constexpr double pi = 3.1415926535897932385;
 
-    static double degrees_to_radians(double degrees);
+inline double degrees_to_radians(double degrees)
-    static double random_double();
+{
-    static double random_double(double min, double max);
+    return degrees * pi / 180;
-    static double clamp(double x, double min, double max);
+}
-};
+
+inline double random_double()
+{
+    // returns a random real in [0,1)
+    return rand() / (RAND_MAX + 1.0);
+}
+
+inline double random_double(double min, double max)
+{
+    // returns a random real in [min,max)
+    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/network.h

@@ -1,9 +0,0 @@
-#pragma once
-
-// file descriptor of the socket we're listening for connections on
-//
-// returns fd for the client connection
-int accept_client(int sockfd);
-int wait_for_client(int& sockfd);
-void send_message(int sock, const char* message);
-void send_image_dimensions(int sock, unsigned int width, unsigned int height);

include/rtweekend.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <memory>
+
+// usings
+
+using std::shared_ptr;
+using std::make_shared;
+using std::sqrt;
+
+// common headers
+
+#include "error.h"
+#include "ray.h"
+#include "vec3.h"

include/scene.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include "math.h"
+#include "sphere.h"
+#include "colour.h"
+#include "material.h"
+#include "hittable.h"
+#include "hittable_list.h"
+
+colour ray_colour(const ray& r, const hittable& world, int depth)
+{
+    hit_record rec;
+    if (depth <= 0)
+    {
+        return grey;
+    }
+
+    if (world.hit(r, 0.001, infinity, rec))
+    {
+        ray     scattered;
+        colour  attenuation;
+
+        if (rec.mat_ptr->scatter(r, rec, attenuation, scattered))
+        {
+            return attenuation * ray_colour(scattered, world, depth-1);
+        }
+
+        return grey;
+    }
+
+    vec3 unit_direction = unit_vector(r.direction());
+    auto t = 0.5 * (unit_direction.y() + 1.0) + 0.5;
+
+    return lerp(grey, pink, t);
+}
+
+hittable_list random_scene()
+{
+    hittable_list world;
+
+
+    //auto ground_material = make_shared<lambertian>(pink);
+    //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 centre(a + 0.9*random_double(), 0.2, b + 0.9*random_double());
+
+    //        if ((centre - point3(4, 0.2, 0)).length() > 0.9)
+    //        {
+    //            shared_ptr<material> sphere_material;
+
+    //            if (choose_mat < 0.8)
+    //            {
+    //                // diffuse
+    //                //auto albedo = colour::random() * colour::random();
+    //                sphere_material = make_shared<lambertian>(pink);
+    //                world.add(make_shared<sphere>(centre, 0.2, sphere_material));
+    //            }
+    //            else if (choose_mat < 0.95)
+    //            {
+    //                // metal
+    //                auto fuzz = random_double(0, 0.5);
+    //                sphere_material = make_shared<metal>(pink, fuzz);
+    //                world.add(make_shared<sphere>(centre, 0.2, sphere_material));
+    //            }
+    //            else
+    //            {
+    //                // glass
+    //                sphere_material = make_shared<dielectric>(1.5);
+    //                world.add(make_shared<sphere>(centre,0.2, sphere_material));
+    //            }
+    //        }
+    //    }
+    //}
+
+    auto material1 = make_shared<dielectric>(1.5);
+    world.add(make_shared<sphere>(point3(0, 0, 0), 3.0, material1));
+
+    //auto material2 = make_shared<lambertian>(pink);
+    //world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));
+    
+    auto material3 = make_shared<metal>(pink, 0.5);
+    int sphere_count = 10;
+    for (int i = 0; i < sphere_count; i++)
+    {
+        float a = 6.28 * (float)i/sphere_count - 100.0;
+        float r = 8.0;
+        float x = r*sin(a);
+        float y = 2.0*cos(a);
+        float z = r*cos(a);
+        point3 pos(x,y,z);
+        world.add(make_shared<sphere>(pos, 2.0, material3));
+    }
+
+    return world;
+}

include/sphere.h

@@ -7,7 +7,7 @@ class sphere : public hittable
 {
     public:
         sphere() {}
-        sphere(point3 centre, double r, std::shared_ptr<material> m) : 
+        sphere(point3 centre, double r, shared_ptr<material> m) : 
             centre_(centre), 
             radius_(r),
             mat_ptr_(m)
@@ -18,6 +18,47 @@ class sphere : public hittable
     private:
         point3                  centre_;
         double                  radius_;
-        std::shared_ptr<material>   mat_ptr_;
+        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() - centre_;
+    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)
+    {
+        auto root = sqrt(discriminant);
+
+        auto temp = (-half_b - root)/a;
+        if (temp < t_max && temp > t_min)
+        {
+            rec.t = temp;
+            rec.p = r.at(rec.t);
+
+            vec3 outward_normal = (rec.p - centre_) / radius_;
+            rec.set_face_normal(r, outward_normal);
+            rec.mat_ptr = mat_ptr_;
+
+            return true;
+        }
+
+        temp = (-half_b + root) / a;
+        if (temp < t_max && temp > t_min)
+        {
+            rec.t = temp;
+            rec.p = r.at(rec.t);
+            
+            vec3 outward_normal = (rec.p - centre_) / radius_;
+            rec.set_face_normal(r, outward_normal);
+            rec.mat_ptr = mat_ptr_;
+            
+            return true;
+        }
+    }
+
+    return false;
+}

include/vec3.h

@@ -7,12 +7,15 @@
 class vec3
 {
 public:
-    static vec3 random();
+    inline static vec3 random()
-    static vec3 random(double min, double max);
+    {
-    static vec3 random_in_unit_disk();
+        return vec3(random_double(),random_double(),random_double());
-    static vec3 random_unit_vector();
+    }
-    static vec3 random_in_unit_sphere();
+
-    static vec3 random_in_hemisphere(const vec3& normal);
+    inline static vec3 random(double min, double max)
+    {
+        return vec3(random_double(min,max),random_double(min,max),random_double(min,max));
+    }
 
     vec3() : e{0,0,0} {}
     vec3(double e0, double e1, double e2) : e{e0, e1, e2} {}
@@ -20,36 +23,108 @@ public:
     double x() const { return e[0]; }
     double y() const { return e[1]; }
     double z() const { return e[2]; }
-    double length() const;
-    double length_squared() const;
 
     vec3 operator-() const { return vec3(-e[0], -e[1], -e[2]); }
     double operator[](int i) const { return e[i]; }
     double& operator[](int i) { return e[i]; }
 
-    vec3& operator+=(const vec3 &v);
+    vec3& operator+=(const vec3 &v)
-    vec3& operator*=(const double t);
+    {
-    vec3& operator/=(const double t);
+        e[0] += v.e[0];
+        e[1] += v.e[1];
+        e[2] += v.e[2];
+        return *this;
+    }
 
-    friend std::ostream& operator<<(std::ostream &out, const vec3 &v);
+    vec3& operator*=(const double t)
-    friend vec3 operator+(const vec3 &u, const vec3 &v);
+    {
-    friend vec3 operator-(const vec3 &u, const vec3 &v);
+        e[0] *= t;
-    friend vec3 operator*(const vec3 &u, const vec3 &v);
+        e[1] *= t;
-    friend vec3 operator*(double t, const vec3 &v);
+        e[2] *= t;
-    friend vec3 operator*(const vec3 &v, double t);
+        return *this;
-    friend vec3 operator/(vec3 v, double t);
+    }
 
-    friend vec3 lerp(const vec3 &a, const vec3 &b, double t);
+    vec3& operator/=(const double t)
-    friend vec3 reflect(const vec3& v, const vec3& n);
+    {
-    friend vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat);
+        return *this *= 1 / t;
-    friend double dot(const vec3 &u, const vec3 &v);
+    }
-    friend vec3 cross(const vec3 &u, const vec3 &v);
-    friend vec3 normalize(vec3 v);
 
-private:
+    double length() const 
+    {
+        return std::sqrt(length_squared());
+    }
+
+    double length_squared() const
+    {
+        return e[0]*e[0] + e[1]*e[1] + e[2]*e[2];
+    }
+
+public:
     double e[3];
 };
 
 // type aliases for vec3
 using point3 = vec3; // 3D point
+using colour = vec3; // RGB colour
+
+// utility functions
+
+inline std::ostream& operator<<(std::ostream &out, const vec3 &v) 
+{
+    return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
+}
+
+inline vec3 operator+(const vec3 &u, const vec3 &v)
+{
+    return vec3(u.e[0] + v.e[0], u.e[1] + v.e[1], u.e[2] + v.e[2]);
+}
+
+inline vec3 operator-(const vec3 &u, const vec3 &v)
+{
+    return vec3(u.e[0] - v.e[0], u.e[1] - v.e[1], u.e[2] - v.e[2]);
+}
+
+inline vec3 operator*(const vec3 &u, const vec3 &v)
+{
+    return vec3(u.e[0] * v.e[0], u.e[1] * v.e[1], u.e[2] * v.e[2]);
+}
+
+inline vec3 operator*(double t, const vec3 &v)
+{
+    return vec3(t * v.e[0], t * v.e[1], t * v.e[2]);
+}
+
+inline vec3 operator*(const vec3 &v, double t)
+{
+    return t * v;
+}
+
+inline vec3 operator/(vec3 v, double t)
+{
+    return (1 / t) * v;
+}
+
+inline double dot(const vec3 &u, const vec3 &v)
+{
+    return u.e[0] * v.e[0]
+         + u.e[1] * v.e[1]
+         + u.e[2] * v.e[2];
+}
+
+inline vec3 cross(const vec3 &u, const vec3 &v)
+{
+    return vec3(u.e[1] * v.e[2] - u.e[2] * v.e[1],
+                u.e[2] * v.e[0] - u.e[0] * v.e[2],
+                u.e[0] * v.e[1] - u.e[1] * v.e[0]);
+}
+
+inline vec3 lerp(const vec3 &a, const vec3 &b, double t)
+{
+    return (1.0 - t) * a + t * b;
+}
+
+inline vec3 unit_vector(vec3 v)
+{
+    return v / v.length();
+}
 

include/world.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "math.h"
-#include "sphere.h"
-#include "colour.h"
-#include "material.h"
-#include "hittable_list.h"
-
-class world : public hittable_list
-{
-public:
-    static world* close_glass_sphere();
-    static world* orb_field();
-
-    friend colour trace(const world& world, const ray& ray, int depth);
-};
-

src/camera.cpp

@@ -1,4 +1,3 @@
-#include "math.h"
 #include "camera.h"
 
 camera::camera(
@@ -10,13 +9,13 @@ camera::camera(
     double  aperture,
     double  focus_dist)
 {
-    auto theta = math::degrees_to_radians(vfov);
+    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_ = normalize(lookfrom - lookat);
+    w_ = unit_vector(lookfrom - lookat);
-    u_ = normalize(cross(vup, w_));
+    u_ = unit_vector(cross(vup, w_));
     v_ = cross(w_, u_);
 
     origin_ = lookfrom;
@@ -29,7 +28,7 @@ camera::camera(
 
 ray camera::get_ray(double s, double t) const
 {
-    vec3 rd = lens_radius_ * vec3::random_in_unit_disk();
+    vec3 rd = lens_radius_ * random_in_unit_disk();
     vec3 offset = (u_ * rd.x()) + (v_ * rd.y());
 
     return ray(

src/camera.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "math.h"
+#include "vec3.h"
+#include "ray.h"
+#include "image.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);
+
+    ray get_ray(double s, double t) const; 
+
+private:
+    point3  origin_;
+    point3  lower_left_corner_;
+    vec3    horizontal_;
+    vec3    vertical_;
+    vec3    u_, v_, w_;
+    double  lens_radius_;
+};

src/colour.cpp

@@ -1,67 +0,0 @@
-#include "colour.h"
-
-colour colour::correct_gamma(int samples)
-{
-    double r = x();
-    double g = y();
-    double b = z();
-
-    // divide the colour total by the number of samples and gamma-correct for gamma=2.0
-    auto scale = 1.0 / samples;
-    r = sqrt(scale * r);
-    g = sqrt(scale * g);
-    b = sqrt(scale * b);
-
-    return colour(r, g, b);
-}
-
-int format_component(double component)
-{
-    return int(256 * math::clamp(component, 0.0, 0.999));
-}
-
-void write_colour_to_socket(int sockfd, colour pixel_colour, int samples_per_pixel)
-{
-    pixel_colour = pixel_colour.correct_gamma(samples_per_pixel);
-
-    int r = format_component(pixel_colour.x());
-    int g = format_component(pixel_colour.y());
-    int b = format_component(pixel_colour.z());
-
-    // pack values
-    int len = 3;
-    char s[len];
-    sprintf(s, "%c%c%c", r, g, b);
-
-    int written = write(sockfd, s, len);
-    if (written < 0)
-    {
-        error("ERROR writing colour to socket");
-    }
-}
-
-void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_per_pixel)
-{
-    pixel_colour = pixel_colour.correct_gamma(samples_per_pixel);
-
-    auto r = pixel_colour.x();
-    auto g = pixel_colour.y();
-    auto b = pixel_colour.z();
-    
-    // write the translated [0,255] value of each colour component.
-    out << format_component(r) << ' '
-        << format_component(g) << ' '
-        << format_component(b) << '\n';
-}
-
-colour operator*(const colour& u, const colour& v)
-{
-    vec3 value = (vec3)u * (vec3)v;
-    return colour(value.x(), value.y(), value.z());
-}
-
-colour lerp(const colour& a, const colour& b, double t)
-{
-    vec3 value = lerp((vec3)a, (vec3)b, t);
-    return colour(value.x(), value.y(), value.z());
-}

src/error.cpp

@@ -1,7 +0,0 @@
-#include "error.h"
-
-void error(const char* message)
-{
-    perror(message);
-    exit(1);
-}

src/foo.cpp

@@ -0,0 +1 @@
+#include "foo.h"

src/hittable_list.cpp

@@ -1,20 +0,0 @@
-#include "hittable_list.h"
-
-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;
-}

src/main.cpp

@@ -1,14 +1,112 @@
+#include "rtweekend.h"
+
+#include "scene.h"
+
 #include "colour.h"
 #include "camera.h"
 #include "material.h"
 #include "image.h"
-#include "world.h"
-#include "network.h"
 
 #include <iostream>
+
 #include <string.h>
 
-void render(camera& cam, const world& world, int client_sock)
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+// file descriptor of the socket we're listening for connections on
+//
+// returns fd for the client connection
+int accept_client(int sockfd)
+{
+    int newsockfd;
+    struct sockaddr_in cli_addr;
+    socklen_t clilen = sizeof(cli_addr);
+
+    newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);
+    if (newsockfd < 0)
+    {
+        error("ERROR accepting client");
+    }
+
+    return newsockfd;
+}
+
+int wait_for_client(int& sockfd)
+{
+    int newsockfd;
+    struct sockaddr_in serv_addr;
+
+    // open socket and await connection from client
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0)
+    {
+        error("ERROR creating socket");
+    }
+
+    bzero((char*)&serv_addr, sizeof(serv_addr));
+
+    // we successfully created the socket, configure it for binding
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_addr.s_addr = INADDR_ANY;
+    serv_addr.sin_port = htons(64999);  // convert number from host to network byte order
+
+    // this is a bit of developer QoL so we can iterate more quickly
+    // TODO: make it possible to disable this debug/release build configuration
+    const int enable = 1;
+    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0)
+    {
+        error("ERROR setsockopt(SO_REUSEADDR) failed");
+    }
+    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0)
+    {
+        error("ERROR setsockopt(SO_REUSEPORT) failed");
+    }
+
+    // bind the socket
+    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
+    {
+        error("ERROR binding socket");
+    }
+
+    // successfully bound socket, start listening for connections
+    listen(sockfd, 5);
+
+    newsockfd = accept_client(sockfd);
+    return newsockfd;
+}
+
+void send_message(int sock, const char* message)
+{
+    int written = write(sock, message, strlen(message));
+    if (written < 0)
+    {
+        error("ERROR sending message to the client");
+    }
+    printf("SEND %s\n", message);
+}
+
+void send_image_dimensions(int sock, unsigned int width, unsigned int height)
+{
+    // https://linux.die.net/man/3/htons
+    width = htonl(width);
+    height = htonl(height);
+
+    int written = write(sock, &width, sizeof(uint32_t));
+    if (written < 0)
+    {
+        error("ERROR writing width");
+    }
+    written = write(sock, &height, sizeof(uint32_t));
+    if (written < 0)
+    {
+        error("ERROR writing height");
+    }
+}
+
+void render(camera& cam, hittable_list& world, int client_sock)
 {
     for (int j = HEIGHT - 1; j >= 0; --j)
     {
@@ -19,10 +117,10 @@ void render(camera& cam, const world& world, int client_sock)
 
             for (int s = 0; s < SAMPLES_PER_PIXEL; ++s)
             {
-                auto u = (i + math::random_double()) / (WIDTH-1);
+                auto u = (i + random_double()) / (WIDTH-1);
-                auto v = (j + math::random_double()) / (HEIGHT-1);
+                auto v = (j + random_double()) / (HEIGHT-1);
                 ray r = cam.get_ray(u, v);
-                pixel_colour += trace(world, r, MAX_DEPTH);
+                pixel_colour += ray_colour(r, world, MAX_DEPTH);
             }
 
             // TODO: we should instead write our output to some buffer in memory
@@ -44,6 +142,8 @@ int main()
 
     //std::cout << "P3\n" << WIDTH << ' ' << HEIGHT << "\n255\n";
 
+    hittable_list world = random_scene();
+
     auto dist_to_target = 10.0;
     auto dist_to_focus = dist_to_target + 1.0;
     auto cam_y = 1.0;
@@ -54,9 +154,7 @@ int main()
 
     camera cam(lookfrom, lookat, vup, 47, ASPECT_RATIO, aperture, dist_to_focus);
 
-    const world* world = world::close_glass_sphere();
+    render(cam, world, newsockfd);
-
-    render(cam, *world, newsockfd);
 
     // close client socket
     close(newsockfd);

src/math.cpp

@@ -1,25 +1 @@
-#include "math.h"
 
-double math::random_double()
-{
-   // returns a random real in [0,1)
-    return rand() / (RAND_MAX + 1.0);
-}
-
-double math::random_double(double min, double max)
-{
-    // returns a random real in [min,max)
-    return min + (max-min)*math::random_double();
-}
-
-double math::degrees_to_radians(double degrees)
-{
-    return degrees * math::pi / 180;
-}
-
-double math::clamp(double x, double min, double max)
-{
-    if (x < min) return min;
-    if (x > max) return max;
-    return x;
-}

src/network.cpp

@@ -1,96 +0,0 @@
-#include "network.h"
-#include "error.h"
-
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <cstring>
-
-int accept_client(int sockfd)
-{
-    int newsockfd;
-    struct sockaddr_in cli_addr;
-    socklen_t clilen = sizeof(cli_addr);
-
-    newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);
-    if (newsockfd < 0)
-    {
-        error("ERROR accepting client");
-    }
-
-    return newsockfd;
-}
-
-int wait_for_client(int& sockfd)
-{
-    int newsockfd;
-    struct sockaddr_in serv_addr;
-
-    // open socket and await connection from client
-    sockfd = socket(AF_INET, SOCK_STREAM, 0);
-    if (sockfd < 0)
-    {
-        error("ERROR creating socket");
-    }
-
-    bzero((char*)&serv_addr, sizeof(serv_addr));
-
-    // we successfully created the socket, configure it for binding
-    serv_addr.sin_family = AF_INET;
-    serv_addr.sin_addr.s_addr = INADDR_ANY;
-    serv_addr.sin_port = htons(64999);  // convert number from host to network byte order
-
-    // this is a bit of developer QoL so we can iterate more quickly
-    // TODO: make it possible to disable this debug/release build configuration
-    const int enable = 1;
-    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0)
-    {
-        error("ERROR setsockopt(SO_REUSEADDR) failed");
-    }
-    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0)
-    {
-        error("ERROR setsockopt(SO_REUSEPORT) failed");
-    }
-
-    // bind the socket
-    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
-    {
-        error("ERROR binding socket");
-    }
-
-    // successfully bound socket, start listening for connections
-    listen(sockfd, 5);
-
-    newsockfd = accept_client(sockfd);
-    return newsockfd;
-}
-
-void send_message(int sock, const char* message)
-{
-    int written = write(sock, message, strlen(message));
-    if (written < 0)
-    {
-        error("ERROR sending message to the client");
-    }
-    printf("SEND %s\n", message);
-}
-
-void send_image_dimensions(int sock, unsigned int width, unsigned int height)
-{
-    // https://linux.die.net/man/3/htons
-    width = htonl(width);
-    height = htonl(height);
-
-    int written = write(sock, &width, sizeof(uint32_t));
-    if (written < 0)
-    {
-        error("ERROR writing width");
-    }
-    written = write(sock, &height, sizeof(uint32_t));
-    if (written < 0)
-    {
-        error("ERROR writing height");
-    }
-}
-

src/sphere.cpp

@@ -1,43 +0,0 @@
-#include "sphere.h"
-
-bool sphere::hit(const ray& r, double t_min, double t_max, hit_record& rec) const 
-{
-    vec3 oc = r.origin() - centre_;
-    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)
-    {
-        auto root = sqrt(discriminant);
-
-        auto temp = (-half_b - root)/a;
-        if (temp < t_max && temp > t_min)
-        {
-            rec.t = temp;
-            rec.p = r.at(rec.t);
-
-            vec3 outward_normal = (rec.p - centre_) / radius_;
-            rec.set_face_normal(r, outward_normal);
-            rec.mat_ptr = mat_ptr_;
-
-            return true;
-        }
-
-        temp = (-half_b + root) / a;
-        if (temp < t_max && temp > t_min)
-        {
-            rec.t = temp;
-            rec.p = r.at(rec.t);
-            
-            vec3 outward_normal = (rec.p - centre_) / radius_;
-            rec.set_face_normal(r, outward_normal);
-            rec.mat_ptr = mat_ptr_;
-            
-            return true;
-        }
-    }
-
-    return false;
-}

src/vec3.cpp

@@ -1,146 +1,13 @@
 #include "vec3.h"
 
-vec3 vec3::random()
+vec3 random_unit_vector()
 {
-    return vec3(math::random_double(),math::random_double(),math::random_double());
+    auto a = random_double(0, 2*pi);
-}
+    auto z = random_double(-1,1);
-
-vec3 vec3::random(double min, double max)
-{
-    return vec3(math::random_double(min,max),math::random_double(min,max),math::random_double(min,max));
-}
-
-vec3 vec3::random_unit_vector()
-{
-    auto a = math::random_double(0, 2 * math::pi);
-    auto z = math::random_double(-1,1);
     auto r = sqrt(1 - z*z);
     return vec3(r*cos(a), r*sin(a), z);
 }
 
-vec3 vec3::random_in_unit_disk()
-{
-    while(true)
-    {
-        auto p = vec3(math::random_double(-1,1), math::random_double(-1,1), 0);
-        if (p.length_squared() >= 1) continue;
-        return p;
-    }
-}
-
-vec3 vec3::random_in_unit_sphere()
-{
-    while (true)
-    {
-        auto p = vec3::random(-1,1);
-        if (p.length_squared() >= 1) continue;
-        return p;
-    }
-}
-
-vec3 vec3::random_in_hemisphere(const vec3& normal)
-{
-    vec3 in_unit_sphere = vec3::random_in_unit_sphere();
-    if (dot(in_unit_sphere, normal) > 0.0)
-    {
-        return in_unit_sphere;
-    }
-    else
-    {
-        return -in_unit_sphere;
-    }
-}
-
-vec3 normalize(vec3 v)
-{
-    return v / v.length();
-}
-
-double vec3::length() const
-{
-    return std::sqrt(length_squared());
-}
-
-double vec3::length_squared() const
-{
-    return e[0]*e[0] + e[1]*e[1] + e[2]*e[2];
-}
-
-vec3& vec3::operator+=(const vec3 &v)
-{
-    e[0] += v.e[0];
-    e[1] += v.e[1];
-    e[2] += v.e[2];
-    return *this;
-}
-
-vec3& vec3::operator*=(const double t)
-{
-    e[0] *= t;
-    e[1] *= t;
-    e[2] *= t;
-    return *this;
-}
-
-vec3& vec3::operator/=(const double t)
-{
-    return *this *= 1 / t;
-}
-
-std::ostream& operator<<(std::ostream &out, const vec3 &v)
-{
-    return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
-}
-
-vec3 operator+(const vec3 &u, const vec3 &v)
-{
-    return vec3(u.e[0] + v.e[0], u.e[1] + v.e[1], u.e[2] + v.e[2]);
-}
-
-vec3 operator-(const vec3 &u, const vec3 &v)
-{
-    return vec3(u.e[0] - v.e[0], u.e[1] - v.e[1], u.e[2] - v.e[2]);
-}
-
-vec3 operator*(const vec3 &u, const vec3 &v)
-{
-    return vec3(u.e[0] * v.e[0], u.e[1] * v.e[1], u.e[2] * v.e[2]);
-}
-
-vec3 operator*(const vec3 &v, double t)
-{
-    return t * v;
-}
-
-vec3 operator*(double t, const vec3 &v)
-{
-    return vec3(t * v.e[0], t * v.e[1], t * v.e[2]);
-}
-
-vec3 operator/(vec3 v, double t)
-{
-    return (1 / t) * v;
-}
-
-vec3 lerp(const vec3 &a, const vec3 &b, double t)
-{
-    return (1.0 - t) * a + t * b;
-}
-
-double dot(const vec3 &u, const vec3 &v)
-{
-    return u[0] * v[0]
-         + u[1] * v[1]
-         + u[2] * v[2];
-}
-
-vec3 cross(const vec3 &u, const vec3 &v)
-{
-    return vec3(u.e[1] * v.e[2] - u.e[2] * v.e[1],
-                u.e[2] * v.e[0] - u.e[0] * v.e[2],
-                u.e[0] * v.e[1] - u.e[1] * v.e[0]);
-}
-
 vec3 reflect(const vec3& v, const vec3& n)
 {
     return v - 2*dot(v,n)*n;
@@ -155,3 +22,36 @@ vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat)
     return r_out_parallel + r_out_perp;
 }
 
+vec3 random_in_unit_disk()
+{
+    while(true)
+    {
+        auto p = vec3(random_double(-1,1), random_double(-1,1), 0);
+        if (p.length_squared() >= 1) continue;
+        return p;
+    }
+}
+
+vec3 random_in_unit_sphere()
+{
+    while (true)
+    {
+        auto p = vec3::random(-1,1);
+        if (p.length_squared() >= 1) continue;
+        return p;
+    }
+}
+
+vec3 random_in_hemisphere(const vec3& normal)
+{
+    vec3 in_unit_sphere = random_in_unit_sphere();
+    if (dot(in_unit_sphere, normal) > 0.0)
+    {
+        return in_unit_sphere;
+    }
+    else
+    {
+        return -in_unit_sphere;
+    }
+}
+

src/world.cpp

@@ -1,54 +0,0 @@
-#include "world.h"
-
-colour trace(const world& world, const ray& r, int depth)
-{
-    hit_record rec;
-    if (depth <= 0)
-    {
-        return grey;
-    }
-
-    if (world.hit(r, 0.001, math::infinity, rec))
-    {
-        ray     scattered;
-        colour  attenuation;
-
-        if (rec.mat_ptr->scatter(r, rec, attenuation, scattered))
-        {
-            return attenuation * trace(world, scattered, depth-1);
-        }
-
-        return grey;
-    }
-
-    vec3 unit_direction = normalize(r.direction());
-    auto t = 0.5 * (unit_direction.y() + 1.0) + 0.5;
-
-    return lerp(grey, pink, t);
-}
-
-world* world::close_glass_sphere()
-{
-    world* w = new world();
-
-    auto material1 = std::make_shared<dielectric>(1.5);
-    w->add(std::make_shared<sphere>(point3(0, 0, 0), 3.0, material1));
-
-    //auto material2 = make_shared<lambertian>(pink);
-    //world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));
-    
-    auto material3 = std::make_shared<metal>(pink, 0.5);
-    int sphere_count = 10;
-    for (int i = 0; i < sphere_count; i++)
-    {
-        float a = 6.28 * (float)i/sphere_count - 100.0;
-        float r = 8.0;
-        float x = r*sin(a);
-        float y = 2.0*cos(a);
-        float z = r*cos(a);
-        point3 pos(x,y,z);
-        w->add(std::make_shared<sphere>(pos, 2.0, material3));
-    }
-
-    return w;
-}

telescope.md

@@ -0,0 +1,25 @@
+fantasy telescope idea
+
+use rti1w as a base
+
+* [x] server waits for connection
+* [x] client establishes connection
+* [x] send a message to the client
+* [x] move core rendering out of main.cpp
+* [ ] combine 'hittable' 'hittable_list' and 'scene'
+* [x] send rendered image data to client
+* [x] form image file on client
+* [ ] client sends receiving port to server
+* [ ] client application sends command to send image
+* [ ] server receives imaging command
+* [ ] server renders image
+* [ ] server sends image data stream to client
+* [ ] client application receives image
+* [ ] client requests resend of lost packets
+* [ ] client displays image
+* [ ] client saves image to file
+* [ ] server sends telemetry to client (what telemetry?)
+* [ ] server compresses image before sending to client
+* [ ] client specifies image parameters
+
+