Compare commits

..

No commits in common. "cd05d5571bb73f54567954006d5a4d645750e97d" and "d244c23e2b60ea0077cc43a12edc2207b6072ea0" have entirely different histories.

24 changed files with 434 additions and 504 deletions

View File

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

View File

@ -1,29 +0,0 @@
#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_;
};

View File

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

View File

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

View File

@ -1,7 +0,0 @@
#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,15 +0,0 @@
#pragma once
#include <cmath>
class math
{
public:
static constexpr double infinity = std::numeric_limits<double>::infinity();
static constexpr double pi = 3.1415926535897932385;
static double degrees_to_radians(double degrees);
static double random_double();
static double random_double(double min, double max);
static double clamp(double x, double min, double max);
};

View File

@ -1,18 +0,0 @@
#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"

View File

@ -1,100 +0,0 @@
#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, math::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 = normalize(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,56 +0,0 @@
#pragma once
#include <iostream>
#include "math.h"
class vec3
{
public:
static vec3 random();
static vec3 random(double min, double max);
static vec3 random_in_unit_disk();
static vec3 random_unit_vector();
static vec3 random_in_unit_sphere();
static vec3 random_in_hemisphere(const vec3& normal);
vec3() : e{0,0,0} {}
vec3(double e0, double e1, double e2) : e{e0, e1, e2} {}
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 double t);
vec3& operator/=(const double t);
friend std::ostream& operator<<(std::ostream &out, const vec3 &v);
friend vec3 operator+(const vec3 &u, const vec3 &v);
friend vec3 operator-(const vec3 &u, const vec3 &v);
friend vec3 operator*(const vec3 &u, const vec3 &v);
friend vec3 operator*(double t, const vec3 &v);
friend vec3 operator*(const vec3 &v, double t);
friend vec3 operator/(vec3 v, double t);
friend vec3 lerp(const vec3 &a, const vec3 &b, double t);
friend vec3 reflect(const vec3& v, const vec3& n);
friend vec3 refract(const vec3& uv, const vec3& n, double etai_over_etat);
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 e[3];
};
// type aliases for vec3
using point3 = vec3; // 3D point
using colour = vec3; // RGB colour

View File

@ -1,38 +0,0 @@
#include "math.h"
#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 = math::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);
u_ = normalize(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_ * vec3::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);
}

51
src/camera.h Normal file
View File

@ -0,0 +1,51 @@
#pragma once
#include "rtweekend.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,9 +8,6 @@
// 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();
@ -26,11 +23,6 @@ void correct_gamma(colour& pixel_colour, int samples)
pixel_colour = colour(r, g, b); pixel_colour = colour(r, g, b);
} }
int format_component(double component)
{
return int(256 * math::clamp(component, 0.0, 0.999));
}
void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_per_pixel) void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_per_pixel)
{ {
correct_gamma(pixel_colour, samples_per_pixel); correct_gamma(pixel_colour, samples_per_pixel);
@ -40,9 +32,14 @@ void write_colour_to_stream(std::ostream &out, colour pixel_colour, int samples_
auto b = pixel_colour.z(); auto b = pixel_colour.z();
// write the translated [0,255] value of each colour component. // write the translated [0,255] value of each colour component.
out << format_component(r) << ' ' out << static_cast<int>(256 * clamp(r, 0.0, 0.999)) << ' '
<< format_component(g) << ' ' << static_cast<int>(256 * clamp(g, 0.0, 0.999)) << ' '
<< format_component(b) << '\n'; << 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) void write_colour_to_socket(int sockfd, colour pixel_colour, int samples_per_pixel)

View File

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

View File

@ -1,11 +1,17 @@
#include "rtweekend.h" #include "rtweekend.h"
#include "scene.h" #include "hittable_list.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>
@ -16,6 +22,110 @@
#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
@ -106,31 +216,6 @@ 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 + math::random_double()) / (WIDTH-1);
auto v = (j + math::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;
@ -154,7 +239,25 @@ 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);
render(cam, world, newsockfd); 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);
}
}
// close client socket // close client socket
close(newsockfd); close(newsockfd);

View File

@ -31,7 +31,7 @@ class lambertian : public material
colour& attenuation, colour& attenuation,
ray& scattered) const 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); scattered = ray(rec.p, scatter_direction);
attenuation = albedo_; attenuation = albedo_;
return true; return true;
@ -54,8 +54,8 @@ class metal : public material
colour& attenuation, colour& attenuation,
ray& scattered) const 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_; attenuation = albedo_;
return dot(scattered.direction(), rec.normal) > 0; return dot(scattered.direction(), rec.normal) > 0;
} }
@ -79,7 +79,7 @@ class dielectric : public material
attenuation = colour(1.0,1.0,1.0); attenuation = colour(1.0,1.0,1.0);
double etai_over_etat = rec.front_face ? (1.0 / refraction_index_) : refraction_index_; 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 cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);
double sin_theta = sqrt(1.0 - cos_theta*cos_theta); double sin_theta = sqrt(1.0 - cos_theta*cos_theta);
@ -91,7 +91,7 @@ class dielectric : public material
} }
double reflect_prob = schlick(cos_theta, etai_over_etat); 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); vec3 reflected = reflect(unit_direction, rec.normal);
scattered = ray(rec.p, reflected); scattered = ray(rec.p, reflected);

View File

@ -1,25 +0,0 @@
#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;
}

View File

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

48
src/rtweekend.h Normal file
View File

@ -0,0 +1,48 @@
#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;
}
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;
}
// common headers
#include "ray.h"
#include "vec3.h"

View File

@ -1,157 +0,0 @@
#include "vec3.h"
vec3 vec3::random()
{
return vec3(math::random_double(),math::random_double(),math::random_double());
}
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;
}
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;
}

185
src/vec3.h Executable file
View File

@ -0,0 +1,185 @@
#pragma once
#include <cmath>
#include <iostream>
#include "rtweekend.h"
class vec3
{
public:
inline static vec3 random()
{
return vec3(random_double(),random_double(),random_double());
}
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} {}
double x() const { return e[0]; }
double y() const { return e[1]; }
double z() const { return e[2]; }
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)
{
e[0] += v.e[0];
e[1] += v.e[1];
e[2] += v.e[2];
return *this;
}
vec3& operator*=(const double t)
{
e[0] *= t;
e[1] *= t;
e[2] *= t;
return *this;
}
vec3& operator/=(const double t)
{
return *this *= 1 / t;
}
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();
}
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;
}

View File

@ -5,8 +5,7 @@ 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
* [x] move core rendering out of main.cpp * [ ] move 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