Learn-RayTracingInOneWeek/material.h at master · Kong25/Learn-RayTracingInOneWeek · 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
#pragma once

#include "rtweekend.h"

struct hit_record;

class material {
public:
    // 控制散射的：入射光线，交点，光线吸收率，以及散射光线
    virtual bool scatter(
        const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
    ) const = 0;
};


// 兰伯特反射
class lambertian : public material {
public:
    lambertian(const color &a) : albedo(a) {}

    virtual bool scatter(
        const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
    ) const override {
        auto scatter_direction = rec.normal + random_unit_vector();

        // Catch degenerate scatter direction
        if (scatter_direction.near_zero())
            scatter_direction = rec.normal;

        scattered = ray(rec.p, scatter_direction);
        attenuation = albedo;
        return true;
    }

public:
    color albedo;
};


//class metal : public material {
//public:
//    metal(const color &a) : albedo(a) {}
//
//    virtual bool scatter(
//        const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
//    ) const override {
//        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
//        scattered = ray(rec.p, reflected);
//        attenuation = albedo;
//        return (dot(scattered.direction(), rec.normal) > 0);
//    }
//
//public:
//    color albedo;
//};


// 带模糊的金属材质
class metal : public material {
public:
    metal(const color &a, double f) : albedo(a), fuzz(f < 1 ? f : 1) {}			// 修改构造函数

    virtual bool scatter(
        const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
    ) const override {
        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
        scattered = ray(rec.p, reflected + fuzz * random_in_unit_sphere());		// 添加随机向量
        attenuation = albedo;
        return (dot(scattered.direction(), rec.normal) > 0);
    }

public:
    color albedo;
    double fuzz;		// 添加模糊度参数
};


// 折射材质
class dielectric : public material {
public:
    dielectric(double index_of_refraction) : ir(index_of_refraction) {}

    virtual bool scatter(
        const ray &r_in, const hit_record &rec, color &attenuation, ray &scattered
    ) const override {
        attenuation = color(1.0, 1.0, 1.0); // 没有衰减，没有颜色。
        double refraction_ratio = rec.front_face ? (1.0 / ir) : ir;

        vec3 unit_direction = unit_vector(r_in.direction());

        double cos_theta = fmin(dot(-unit_direction, rec.normal), 1.0);		// 此处以下有修改
        double sin_theta = sqrt(1.0 - cos_theta * cos_theta);

        bool cannot_refract = refraction_ratio * sin_theta > 1.0;
        vec3 direction;

        if (cannot_refract || reflectance(cos_theta, refraction_ratio) > random_double())// 1、折射率判断 2、Schlick近似判断（增加真实感）
            direction = reflect(unit_direction, rec.normal);  // 全内反射
        else
            direction = refract(unit_direction, rec.normal, refraction_ratio); // 正常折射，给给折射方向

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

public:
    double ir; // Index of Refraction

private:
    static double reflectance(double cosine, double ref_idx) {	// 改动的地方
            // Use Schlick's approximation for reflectance.
        auto r0 = (1 - ref_idx) / (1 + ref_idx);
        r0 = r0 * r0;
        return r0 + (1 - r0) * pow((1 - cosine), 5);
    }
};