Compare commits

...

3 Commits

Author SHA1 Message Date
Cat Flynn bd444aba2e wip 2023-02-19 01:10:53 +00:00
Cat Flynn ed4243cf89 extract image constants to file 2023-02-18 18:50:48 +00:00
Cat Flynn 5a92d1874e extract scene functionality from main.cpp 2023-02-18 18:35:15 +00:00
22 changed files with 340 additions and 254 deletions

View File

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

52
include/camera.h Normal file
View File

@ -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_;
};

View File

@ -8,6 +8,9 @@
// for writing to socket // for writing to socket
#include <unistd.h> #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) void correct_gamma(colour& pixel_colour, int samples)
{ {
double r = pixel_colour.x(); double r = pixel_colour.x();

7
include/error.h Normal file
View File

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

1
include/foo.h Normal file
View File

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

7
include/image.h Normal file
View File

@ -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;

View File

@ -1,23 +1,10 @@
#pragma once #pragma once
#include <cmath> #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 infinity = std::numeric_limits<double>::infinity();
const double pi = 3.1415926535897932385; const double pi = 3.1415926535897932385;
// utility functions
inline double degrees_to_radians(double degrees) inline double degrees_to_radians(double degrees)
{ {
return degrees * pi / 180; return degrees * pi / 180;
@ -41,8 +28,3 @@ inline double clamp(double x, double min, double max)
if (x > max) return max; if (x > max) return max;
return x; return x;
} }
// common headers
#include "ray.h"
#include "vec3.h"

View File

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

18
include/rtweekend.h Normal file
View File

@ -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"

100
include/scene.h Normal file
View File

@ -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;
}

View File

@ -1,9 +1,8 @@
#pragma once #pragma once
#include <cmath>
#include <iostream> #include <iostream>
#include "rtweekend.h" #include "math.h"
class vec3 class vec3
{ {
@ -129,57 +128,3 @@ inline vec3 unit_vector(vec3 v)
return v / v.length(); 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;
}

37
src/camera.cpp Normal file
View File

@ -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);
}

View File

@ -1,51 +1,29 @@
#pragma once #pragma once
#include "rtweekend.h" #include "math.h"
#include "vec3.h"
#include "ray.h"
#include "image.h"
class camera class camera
{ {
public: public:
camera( camera(
point3 lookfrom, point3 lookfrom,
point3 lookat, point3 lookat,
vec3 vup, vec3 vup,
double vfov, // vertical field of view in degrees double vfov, // vertical field of view in degrees
double aspect_ratio, double aspect_ratio,
double aperture, 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;
w_ = unit_vector(lookfrom - lookat); ray get_ray(double s, double t) const;
u_ = unit_vector(cross(vup, w_));
v_ = cross(w_, u_);
origin_ = lookfrom; private:
horizontal_ = focus_dist * viewport_width * u_; point3 origin_;
vertical_ = focus_dist * viewport_height * v_; point3 lower_left_corner_;
lower_left_corner_ = origin_ - horizontal_/2 - vertical_/2 - focus_dist * w_; vec3 horizontal_;
vec3 vertical_;
lens_radius_ = aperture / 2; vec3 u_, v_, w_;
} double lens_radius_;
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_;
}; };

1
src/foo.cpp Normal file
View File

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

View File

@ -1,17 +1,11 @@
#include "rtweekend.h" #include "rtweekend.h"
#include "hittable_list.h" #include "scene.h"
#include "sphere.h"
void error(const char* message)
{
perror(message);
exit(1);
}
#include "colour.h" #include "colour.h"
#include "camera.h" #include "camera.h"
#include "material.h" #include "material.h"
#include "image.h"
#include <iostream> #include <iostream>
@ -22,110 +16,6 @@ void error(const char* message)
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.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 // file descriptor of the socket we're listening for connections on
// //
// returns fd for the client connection // 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 main()
{ {
int sockfd; int sockfd;
@ -239,25 +154,7 @@ int main()
camera cam(lookfrom, lookat, vup, 47, ASPECT_RATIO, aperture, dist_to_focus); camera cam(lookfrom, lookat, vup, 47, ASPECT_RATIO, aperture, dist_to_focus);
for (int j = HEIGHT - 1; j >= 0; --j) render(cam, world, newsockfd);
{
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);
}
}
// close client socket // close client socket
close(newsockfd); close(newsockfd);

1
src/math.cpp Normal file
View File

@ -0,0 +1 @@

57
src/vec3.cpp Normal file
View File

@ -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;
}
}

View File

@ -5,7 +5,8 @@ use rti1w as a base
* [x] server waits for connection * [x] server waits for connection
* [x] client establishes connection * [x] client establishes connection
* [x] send a message to the client * [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] send rendered image data to client
* [x] form image file on client * [x] form image file on client
* [ ] client sends receiving port to server * [ ] client sends receiving port to server