toytracer/wtracer.cpp

#include <iostream>
#include <iomanip>
#include <memory>
#include <cstdio>

#define LODEPNG_NO_COMPILE_DECODER
#include "lodepng.h"

#ifdef _OPENMP
#include <omp.h>
#endif

#include "color.h"
#include "vec3.h"
#include "ray.h"
#include "util.h"
#include "hittable_list.h"
#include "sphere.h"
#include "camera.h"

Color ray_color(const Ray& r, const Hittable& world, int depth) {
    hit_record rec;

    if (depth <= 0)
        return Color(0, 0, 0);

    if (world.hit(r, 0.001, infinity, rec)) {
        Ray scattered;
        Color attenuation;
        if (rec.mat_ptr->scatter(r, rec, attenuation, scattered))
          return attenuation * ray_color(scattered, world, depth - 1);
        return Color(0, 0, 0);
    }
    Vec3 unit_direction = unit_vector(r.direction());
    auto t = 0.5 * (unit_direction.y() + 1.0);
    return (1.0 - t) * Color(1.0, 1.0, 1.0) + t * Color(0.5, 0.7, 1.0);
}

Hittable_list setup_random_scene() {
    Hittable_list world;

    const int sph_i = 3;

    auto ground_material = std::make_shared<Lambertian>(Color(0.5, 0.5, 0.5));
    world.add(std::make_shared<Sphere>(Point3(0, -1000, 0), 1000, ground_material));
    for (int a = -sph_i; a<sph_i; a++) {
        for (int b = -sph_i; b<sph_i; b++) {
            auto choose_mat = random_double();
            Point3 center(a + 0.9 * (11/sph_i) * random_double(), 0.2, b + 0.9 * (11/sph_i) * random_double());

            if ((center - Point3(4, 0.2, 0)).length() > 0.9) {
                std::shared_ptr<Material> sphere_material;
                if (choose_mat < 0.8) {
                    // diffuse
                    auto albedo = Color::random() * Color::random();
                    sphere_material = std::make_shared<Lambertian>(albedo);
                    world.add(std::make_shared<Sphere>(center, 0.2, sphere_material));
                } else if (choose_mat < 0.95) {
                    // metal
                    auto albedo = Color::random(0.5, 1);
                    auto fuzz = random_double(0, 0.5);

                    sphere_material = std::make_shared<Metal>(albedo, fuzz);
                    world.add(std::make_shared<Sphere>(center, 0.2, sphere_material));
                } else {
                    // glass
                    sphere_material = std::make_shared<Dielectric>(1.45);
                    world.add(std::make_shared<Sphere>(center, 0.2, sphere_material));
                }
            }
        }
    }

    auto material1 = std::make_shared<Dielectric>(1.45);
    world.add(std::make_shared<Sphere>(Point3(0, 1, 0), 1.0, material1));

    auto material2 = std::make_shared<Lambertian>(Color(0.4, 0.2, 0.1));
    world.add(std::make_shared<Sphere>(Point3(-4, 1, 0), 1.0, material2));

    auto material3 = std::make_shared<Metal>(Color(0.7, 0.6, 0.5), 0.0);
    world.add(std::make_shared<Sphere>(Point3(4, 1, 0), 1.0, material3));

    return world;
}

struct render_params {
    int image_width;
    int image_height;
    int samples_per_pixel;
    int max_depth;
    Hittable_list& world;
    Camera& cam;
};

void split_line(const int& line_length, int& start, int& end) {
#ifdef _OPENMP
    const int line_length_thread = static_cast<int>(line_length/omp_get_num_threads());
    start = omp_get_thread_num() * line_length_thread;
    end = std::min((omp_get_thread_num()+1) * line_length_thread, line_length);
#else
    start = 0;
    end = line_length;
#endif
}

void render(const render_params& params, std::vector<Color>& image) {
    int line_start, line_end;
    split_line(params.image_width, line_start, line_end);
    for (int i = params.image_height-1; i>=0; --i) {
        #ifdef _OPENMP
        if (omp_get_thread_num() == 0)
        #endif
        std::cerr << "\rScanline remaining: " << std::setw(4) << i << std::flush;
        for (int j = line_start; j<line_end; ++j) {
            Color pixel_color(0, 0, 0);
            for (int s = 0; s<params.samples_per_pixel; ++s) {
                auto u = double(j + random_double(-0.5, 0.5)) / (params.image_width - 1);
                auto v = double(i + random_double(-0.5, 0.5)) / (params.image_height - 1);
                Ray r = params.cam.get_ray(u, v);
                pixel_color += ray_color(r, params.world, params.max_depth);
            }
            image[i*params.image_width+j] = pixel_color;
        }
    }
}

int main() {
    const auto aspect_ratio = 16.0 / 9.0;
    //const int image_width = 1280;
    //const int image_width = 768;
    const int image_width = 384;
    const int image_height = static_cast<int>(image_width / aspect_ratio);
    //const int samples_per_pixel = 1000;
    const int samples_per_pixel = 400;
    const int max_depth = 50;

    auto world = setup_random_scene();

    Point3 lookfrom(13, 2, 3);
    Point3 lookat(0, 0, 0);
    Vec3 vup(0, 1, 0);
    auto dist_to_focus = (lookfrom - lookat).length();
    auto aperture = 0.1;

    Camera cam(lookfrom, lookat, vup, 20, aspect_ratio, aperture, dist_to_focus);

    render_params params = {
        image_width,
        image_height,
        samples_per_pixel,
        max_depth,
        world,
        cam,
    };

    std::vector<Color> image(image_width * image_height);

    #pragma omp parallel
    {
        render(params, image);
    }

    std::cerr << "\nAssembling image.\n";

    std::vector<unsigned char> img_lode(image_width * image_height * 3);
    for (int i = 0; i<image_height; ++i) {
        for (int j = 0; j<image_width; ++j) {
            write_color_vec(img_lode, i*image_width*3+j*3, image[(image_height-1-i)*image_width+j], samples_per_pixel);
        }
    }
    std::cerr << "Writing file \"image.png\".\n";

    unsigned error = lodepng::encode("image.png", img_lode, image_width, image_height, LCT_RGB);

    if (error)
        std::cerr << "lodepng encoder error " << error << ": "<< lodepng_error_text(error) << std::endl;

    std::cerr << "Done.\n";
}