Raytracer/material.h at master · pieroevcc/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
#ifndef MATERIAL_H
#define MATERIAL_H

#include "hittable.h"
#include <memory>
#include "ray.h"
#include "vec3.h"


class Material {
    public:
        virtual ~Material() = default;
        virtual bool scatter(const Ray& r_in, const hit_record& rec, Vector3& attenuation, Ray& scattered) const = 0;
};

class Lambertian : public Material {
    public:
        Vector3 albedo;
        Lambertian(){}

        Lambertian(const Vector3& albedo){
            this->albedo = albedo;
        }

        bool scatter(const Ray& r_in, const hit_record& rec, Vector3& attenuation, Ray& scattered) const override{
            Vector3 dir = rec.N + random_unit_vector();
            if(near_zero(dir)) dir = rec.N;
            scattered = Ray(rec.p, dir);
            attenuation = albedo;
            return true;
        }
};

class Metal : public Material{
    public:
        Vector3 albedo;
        float fuzz;

        Metal(){}

        Metal(const Vector3& albedo, float fuzz){
            this->albedo = albedo;
            this->fuzz = (fuzz < 1.0f) ? fuzz : 1.0f;
        }

        bool scatter(const Ray& r_in, const hit_record& rec, Vector3& attenuation, Ray& scattered) const override{
            Vector3 reflected = reflect(unit(r_in.direction), rec.N);
            reflected = unit(reflected) + fuzz * random_unit_vector();
            scattered = Ray(rec.p, reflected);
            attenuation = albedo;
            return (dot(scattered.direction, rec.N) > 0);
        }

};

class Dielectric : public Material {
    public:
        float refraction_index;
        Dielectric(float ri) : refraction_index(ri) {}

        bool scatter(const Ray& r_in, const hit_record& rec,
                     Vector3& attenuation, Ray& scattered) const override {
            attenuation = Vector3(1.0f, 1.0f, 1.0f);
            float ri = rec.front_face ? (1.0f / refraction_index) : refraction_index;

            Vector3 unit_dir = unit(r_in.direction);
            float cos_theta = fminf(dot(neg(unit_dir), rec.N), 1.0f);
            float sin_theta = sqrtf(1.0f - cos_theta * cos_theta);

            bool cannot_refract = ri * sin_theta > 1.0f;
            Vector3 direction;
            if (cannot_refract || reflectance(cos_theta, ri) > rand_float())
                direction = reflect(unit_dir, rec.N);
            else
                direction = refract(unit_dir, rec.N, ri);

            scattered = Ray(rec.p, direction);
            return true;
        }

    private:
        static float reflectance(float cosine, float ri) {
            float r0 = (1.0f - ri) / (1.0f + ri);
            r0 = r0 * r0;
            return r0 + (1.0f - r0) * powf(1.0f - cosine, 5.0f);
        }
};

#endif