material.h

#ifndef MATERIAL_H
#define MATERIAL_H

#include "hittable.h"

class material {
public:
    virtual ~material() = default;

    virtual bool scatter(
        const ray& ray_in, const hit_record& rec, color& attenuation, ray& scattered
    ) const {
        return false;
    }
};

class lambertian : public material {
private:
    color albedo;
public:
    lambertian(const color& albedo) : albedo(albedo) {}

    bool scatter(const ray& ray_in, const hit_record& rec, color& attenuation, ray& scattered)
    const override {
        // Lambertian Reflection
        // Sphere (which tangent to the surface) center P
        // Normal n
        // Random point on the sphere S: P + n + random_unit_vector()
        // From hit point p to S: S - p = n + random_unit_vector()
        vec3 scatter_direction = rec.normal + random_unit_vector();

        if (scatter_direction.near_zero())
            scatter_direction = rec.normal;

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

class metal : public material {
private:
    color albedo;
    double fuzz;
public:
    metal(const color& albedo, double fuzz) : albedo(albedo), fuzz(fuzz < 1 ? fuzz : 1) {}

    bool scatter(const ray& ray_in, const hit_record& rec, color& attenuation, ray& scattered)
    const override {
        auto reflected = reflect(ray_in.direction(), rec.normal);
        // Normalized reflected vector in order to make the displacement
        reflected = unit_vector(reflected) + (fuzz * random_unit_vector());
        scattered = ray(rec.p, reflected);
        attenuation = albedo;
        // Absorb grazing rays or too large fuzz sphere
        return (dot(scattered.direction(), rec.normal) > 0);
    }
};

class dielectric : public material {
private:
    double refraction_index;

    static double reflectance(double cos_theta, double refraction_index) {
        // Use Schlick's approximation for reflectance
        auto r0 = (1 - refraction_index) / (1 + refraction_index);
        r0 = r0 * r0;
        return r0 + (1 - r0) * std::pow((1 - cos_theta), 5);
    }
public:
    dielectric(double refraction_index) : refraction_index(refraction_index) {}

    bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered)
    const override {
        attenuation = color(1.0, 1.0, 1.0);
        vec3 unit_direction = unit_vector(r_in.direction());

        // From air -> surface or from surface -> air
        double ri = rec.front_face ? (1.0 / refraction_index) : refraction_index;

        double cos_theta = std::fmin(dot(-unit_direction, rec.normal), 1.0);
        double sin_theta = std::sqrt(1 - cos_theta * cos_theta);
        bool cannot_refract = ri * sin_theta > 1.0; // Refract formula has no solution

        vec3 direction;

        if (cannot_refract || reflectance(cos_theta, refraction_index) > random_double())
            direction = reflect(unit_direction, rec.normal);
        else
            direction = refract(unit_direction, rec.normal, ri);
        
        scattered = ray(rec.p, direction);
        return true;
    }
};

#endif