Raytracer/camera.h at main · Gelehead/Raytracer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#ifndef CAMERA_H
#define CAMERA_H

#include "rtweekend.h"
#include "hittable.h"

class camera {
    public:
        double aspect_ratio     = 1.0;
        int    image_width      = 100;
        int    sample_per_pixel = 10;
        int    max_depth        = 10;

        point3 lookfrom = point3(0,0,0);
        point3 lookat   = point3(0,0,-1);
        vec3   vup      = vec3(0,1,0);


        void render(const hittable& world) {
            initialize();

            std::cout << "P3\n" << image_width << " " << image_height << "\n255\n";


            for (int j = 0 ; j < image_height ; j++){
                std::clog << "\rScanlines remaining: " << (image_height - j) << ' ' << std::flush;
                for (int i = 0 ; i < image_width ; i++) {
                    color pixel_color = color(0, 0, 0);
                    for (int samples = 0; samples < sample_per_pixel; samples++){
                        ray r = get_ray(i, j);
                        pixel_color += ray_color(r, max_depth, world);
                    }
                    write_color(std::cout, pixel_sample_scale * pixel_color);
                }
            }

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

    private:
        int    image_height;   // Rendered image height
        double pixel_sample_scale; // color sacl efactor for a sum of pixel samples
        point3 center;         // Camera center
        point3 pixel00_loc;    // Location of pixel 0, 0
        vec3   pixel_delta_u;  // Offset to pixel to the right
        vec3   pixel_delta_v;  // Offset to pixel below

        vec3   u, v, w;         // Camera frame basis vectors

        void initialize() {
            image_height = int(image_width / aspect_ratio);
            image_height = (image_height < 1) ? 1 : image_height;

            center = lookfrom;

            pixel_sample_scale = 1.0 / sample_per_pixel;

            // Determine viewport dimensions.
            auto focal_length = (lookfrom - lookat).length();
            auto viewport_height = 2.0;
            auto viewport_width = viewport_height * (double(image_width)/image_height);


            // Calculate the u, v, wunit basis vectors for the camera coordinate frame
            w = unit_vector(lookfrom - lookat);
            u = unit_vector(cross(vup, w));
            v = cross(w, u);

            // Calculate the vectors across the horizontal and down the vertical viewport edges.
            vec3 viewport_u = viewport_width * u;
            vec3 viewport_v = viewport_height * -v;

            // Calculate the horizontal and vertical delta vectors from pixel to pixel.
            pixel_delta_u = viewport_u / image_width;
            pixel_delta_v = viewport_v / image_height;

            // Calculate the location of the upper left pixel.
            auto viewport_upper_left = center - (focal_length * w) - viewport_u/2 - viewport_v/2;
            pixel00_loc = viewport_upper_left + 0.5 * (pixel_delta_u + pixel_delta_v);
        }

        ray get_ray(int i, int j) const {
            // constructs a camera ray originating from the origin and directed at randomly
            // sampled points around the pixel location (i, j)

            auto offset = sample_square();
            auto pixel_sample = pixel00_loc
                            + ((i + offset.x()) * pixel_delta_u)
                            + ((j + offset.y()) * pixel_delta_v);

            auto ray_origin = center;
            auto ray_direction = pixel_sample - ray_origin;

            return ray(ray_origin, ray_direction);
        }

        color ray_color(const ray& r, int depth, const hittable& world) const {
            if (depth <= 0) {
                return color(0,0,0);
            }

            hit_record rec;
            if (world.hit(r, interval(0.0001, infinity), rec)){
                vec3 direction = random_on_hemisphere(rec.normal);
                return 0.5 * ray_color(ray(rec.p, direction), depth - 1, world);
            }

            vec3 unit_direction = unit_vector(r.direction());
            auto a = 0.5*(r.direction().y() + 1.0);
            return (1.0 - a) * color(1.0, 1.0, 1.0) + a * color(0.5, 0.7, 1.0);
        }

        vec3 sample_square() const {
            // returns the vector to a sample point within the [- 0.5, - 0.5] - [+ 0.5, + 0.5] unit square
            return vec3(random_double() - 0.5, random_double() - 0.5, 0);
        }

};

#endif