100 lines
2.9 KiB
C++
100 lines
2.9 KiB
C++
#ifndef MATERIAL_H
|
|
#define MATERIAL_H
|
|
|
|
#include "rtweekend.hpp"
|
|
|
|
struct material {
|
|
virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const = 0;
|
|
};
|
|
|
|
struct lambertian : material {
|
|
/* Attributes */
|
|
color albedo;
|
|
// Constructor
|
|
lambertian(const color& c) { albedo = c; }
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
|
virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const override
|
|
{
|
|
vec3 scatter_direction = rec.normal + random_unit_vector();
|
|
|
|
/* NOTE: it is possible that the random vector we generate is exactly opposite to the normal vector,
|
|
in which case it will sum to a near-zero scatter vector and generate degenerate results.
|
|
We check for near-zero vectors here.
|
|
*/
|
|
|
|
if (scatter_direction.near_zero())
|
|
scatter_direction = rec.normal;
|
|
|
|
scattered = ray(rec.p, scatter_direction);
|
|
attenuation = albedo;
|
|
return true;
|
|
}
|
|
#pragma GCC diagnostic pop
|
|
};
|
|
|
|
struct metal : material {
|
|
/* Attributes */
|
|
color albedo;
|
|
double fuzz;
|
|
// Constructor
|
|
metal(const color& c, double f)
|
|
{
|
|
albedo = c;
|
|
fuzz = f;
|
|
};
|
|
|
|
virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const override
|
|
{
|
|
vec3 reflected = reflect(normalize(r_in.direction), rec.normal);
|
|
scattered = ray(rec.p, reflected + fuzz*random_in_unit_sphere());
|
|
attenuation = albedo;
|
|
return (dot(scattered.direction, rec.normal) > 0);
|
|
}
|
|
};
|
|
|
|
struct dielectric : material
|
|
{
|
|
/* Attributes */
|
|
double ri; // refraction index
|
|
|
|
// Constructor
|
|
dielectric(double refraction_index) { ri = refraction_index; }
|
|
|
|
/* Methods */
|
|
|
|
// Schlick's approximation of reflectance
|
|
static double reflectance(double cosine, double ref_idx)
|
|
{
|
|
double r0 = (1-ref_idx) / (1+ref_idx);
|
|
r0 = r0*r0;
|
|
return r0 + (1-r0)*pow((1 - cosine), 5);
|
|
}
|
|
|
|
|
|
/* Virtual methods */
|
|
virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const override
|
|
{
|
|
attenuation = color(1,1,1);
|
|
double refraction_ratio = rec.front_face ? (1.0/ri) : ri;
|
|
|
|
vec3 unit_direction = normalize(r_in.direction);
|
|
|
|
double cos_theta = fmin(dot(-unit_direction, rec.normal), 1);
|
|
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())
|
|
direction = reflect(unit_direction, rec.normal);
|
|
else
|
|
direction = refract(unit_direction, rec.normal, refraction_ratio);
|
|
|
|
scattered = ray(rec.p, direction);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
#endif
|