wip

CMakeLists.txt

@@ -2,10 +2,8 @@ cmake_minimum_required(VERSION 3.10)
 
 project(snoopy)
 
-file(GLOB snoopy_src
-    "src/*.h"
-    "src/*.cpp"
-)
+include_directories("include")
+file(GLOB SOURCES "src/*.cpp")
 
-add_executable(snoopy ${snoopy_src})
+add_executable(snoopy ${SOURCES})
 

include/camera.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "rtweekend.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)
+        {
+            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_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_;
+        vec3    vertical_;
+        vec3    u_, v_, w_;
+        double  lens_radius_;
+};

include/colour.h

@@ -8,6 +8,9 @@
 // for writing to socket
 #include <unistd.h>
 
+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();

include/error.h

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

include/foo.h

@@ -0,0 +1 @@
+#include <iostream>

include/image.h

@@ -0,0 +1,7 @@
+#pragma once
+
+const double ASPECT_RATIO = 1.0;
+const unsigned int WIDTH = 256;
+const unsigned int HEIGHT = static_cast<int>(WIDTH / ASPECT_RATIO);
+const int SAMPLES_PER_PIXEL = 8;
+const int MAX_DEPTH = 5;

include/math.h

@@ -1,23 +1,10 @@
 #pragma once
 
 #include <cmath>
-#include <cstdlib>
-#include <limits>
-#include <memory>
-
-// 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;
@@ -41,8 +28,3 @@ inline double clamp(double x, double min, double max)
     if (x > max) return max;
     return x;
 }
-
-// common headers
-
-#include "ray.h"
-#include "vec3.h"

include/ray.h

@@ -23,3 +23,4 @@ private:
     point3  origin_;
     vec3    direction_;
 };
+

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/vec3.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include <cmath>
 #include <iostream>
 
-#include "rtweekend.h"
+#include "math.h"
 
 class vec3
 {
@@ -129,57 +128,3 @@ inline vec3 unit_vector(vec3 v)
     return v / v.length();
 }
 
-vec3 random_in_unit_sphere()
-{
-    while (true)
-    {
-        auto p = vec3::random(-1,1);
-        if (p.length_squared() >= 1) continue;
-        return p;
-    }
-}
-
-vec3 random_unit_vector()
-{
-    auto a = random_double(0, 2*pi);
-    auto z = random_double(-1,1);
-    auto r = sqrt(1 - z*z);
-    return vec3(r*cos(a), r*sin(a), z);
-}
-
-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;
-    }
-}
-
-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 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 = dot(-uv, n);
-    vec3 r_out_parallel = etai_over_etat * (uv + cos_theta*n);
-    vec3 r_out_perp = -sqrt(1.0 - r_out_parallel.length_squared()) * n;
-
-    return r_out_parallel + r_out_perp;
-}

src/camera.cpp

@@ -0,0 +1,37 @@
+#include "camera.h"
+
+camera::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 camera::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);
+}

src/camera.h

@@ -1,10 +1,13 @@
 #pragma once
 
-#include "rtweekend.h"
+#include "math.h"
+#include "vec3.h"
+#include "ray.h"
+#include "image.h"
 
 class camera
 {
-    public:
+public:
     camera(
         point3  lookfrom,
         point3  lookat,
@@ -12,36 +15,11 @@ class camera
         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;
+        double  focus_dist);
 
-            w_ = unit_vector(lookfrom - lookat);
-            u_ = unit_vector(cross(vup, w_));
-            v_ = cross(w_, u_);
+    ray get_ray(double s, double t) const; 
 
-            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:
+private:
     point3  origin_;
     point3  lower_left_corner_;
     vec3    horizontal_;

src/foo.cpp

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

src/main.cpp

@@ -1,17 +1,11 @@
 #include "rtweekend.h"
 
-#include "hittable_list.h"
-#include "sphere.h"
-
-void error(const char* message)
-{
-    perror(message);
-    exit(1);
-}
+#include "scene.h"
 
 #include "colour.h"
 #include "camera.h"
 #include "material.h"
+#include "image.h"
 
 #include <iostream>
 
@@ -22,110 +16,6 @@ void error(const char* message)
 #include <sys/socket.h>
 #include <netinet/in.h>
 
-const double ASPECT_RATIO = 1.0;
-const unsigned int WIDTH = 256;
-const unsigned int HEIGHT = static_cast<int>(WIDTH / ASPECT_RATIO);
-const int SAMPLES_PER_PIXEL = 8;
-const int MAX_DEPTH = 5;
-
-// fee2aa
-// 
-const colour pink(254.0/255.0, 226.0/255.0, 170.0/255.0);
-const colour grey(0.133, 0.133, 0.133);
-
-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;
-}
-
 // file descriptor of the socket we're listening for connections on
 //
 // returns fd for the client connection
@@ -216,6 +106,31 @@ void send_image_dimensions(int sock, unsigned int width, unsigned int height)
     }
 }
 
+void render(camera& cam, hittable_list& world, int client_sock)
+{
+    for (int j = HEIGHT - 1; j >= 0; --j)
+    {
+        std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
+        for (int i = 0; i < WIDTH; ++i)
+        {
+            colour pixel_colour(0,0,0);
+
+            for (int s = 0; s < SAMPLES_PER_PIXEL; ++s)
+            {
+                auto u = (i + random_double()) / (WIDTH-1);
+                auto v = (j + random_double()) / (HEIGHT-1);
+                ray r = cam.get_ray(u, v);
+                pixel_colour += ray_colour(r, world, MAX_DEPTH);
+            }
+
+            // TODO: we should instead write our output to some buffer in memory
+            // to decouple our ultimate output from our rendering
+            //write_colour_to_stream(std::cout, pixel_colour, SAMPLES_PER_PIXEL);
+            write_colour_to_socket(client_sock, pixel_colour, SAMPLES_PER_PIXEL);
+        }
+    }
+}
+
 int main()
 {
     int sockfd;
@@ -239,25 +154,7 @@ int main()
 
     camera cam(lookfrom, lookat, vup, 47, ASPECT_RATIO, aperture, dist_to_focus);
 
-    for (int j = HEIGHT - 1; j >= 0; --j)
-    {
-        std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
-        for (int i = 0; i < WIDTH; ++i)
-        {
-            colour pixel_colour(0,0,0);
-
-            for (int s = 0; s < SAMPLES_PER_PIXEL; ++s)
-            {
-                auto u = (i + random_double()) / (WIDTH-1);
-                auto v = (j + random_double()) / (HEIGHT-1);
-                ray r = cam.get_ray(u, v);
-                pixel_colour += ray_colour(r, world, MAX_DEPTH);
-            }
-
-            //write_colour_to_stream(std::cout, pixel_colour, SAMPLES_PER_PIXEL);
-            write_colour_to_socket(newsockfd, pixel_colour, SAMPLES_PER_PIXEL);
-        }
-    }
+    render(cam, world, newsockfd);
 
     // close client socket
     close(newsockfd);

src/math.cpp

@@ -0,0 +1 @@
+

src/vec3.cpp

@@ -0,0 +1,57 @@
+#include "vec3.h"
+
+vec3 random_unit_vector()
+{
+    auto a = random_double(0, 2*pi);
+    auto z = random_double(-1,1);
+    auto r = sqrt(1 - z*z);
+    return vec3(r*cos(a), r*sin(a), z);
+}
+
+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 = dot(-uv, n);
+    vec3 r_out_parallel = etai_over_etat * (uv + cos_theta*n);
+    vec3 r_out_perp = -sqrt(1.0 - r_out_parallel.length_squared()) * n;
+
+    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;
+    }
+}
+

telescope.md

@@ -5,7 +5,8 @@ use rti1w as a base
 * [x] server waits for connection
 * [x] client establishes connection
 * [x] send a message to the client
-* [ ] move rendering out of main.cpp
+* [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