lights.cpp

#include "lights.h"
#include "scene.h"
#include "shapes.h"
#include "vector.h"
#include <cmath>
#include <iostream>
#include <stdexcept>

Vector3 PointLight::sample(Vector3 point, Vector3 normal, Scene& scene) const {
    Vector3 light_vec = position - point;
    float dist2 = light_vec.dot(light_vec);

    // Avoid division by zero
    if (dist2 < 1e-6f) return Vector3();

    float dist = std::sqrt(dist2);
    Vector3 L = light_vec / dist;

    // Cosine term
    float NdotL = normal.dot(L);
    if (NdotL <= 0.0f) return Vector3();

    // Shadow ray
    Vector3 origin = point + L * 1e-4f;
    Vector3 inv_L = 1 / L;
    CollisionInfo shadow = scene.intersectRay(origin, L, inv_L);
    if (shadow.hit && shadow.distance < dist) return Vector3();

    // Inverse square falloff
    Vector3 radiance = color * intensity * (NdotL / dist2);

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 PointLight::sample(Vector3 point, Vector3 normal, Vector3 view, Scene& scene) const {
    return Vector3(0, 0, 0); // On a mirror surface, a point light is never hit
}

Vector3 DirectionalLight::sample(Vector3 point, Vector3 normal, Scene& scene) const {
    // Shadow ray check
    Vector3 shadow_direction = direction * -1;
    Vector3 inv_shadow = 1 / shadow_direction;
    Vector3 origin = point + normal * 0.001;
    CollisionInfo shadow = scene.intersectRay(origin, shadow_direction, inv_shadow);
    if (shadow.hit) return Vector3();

    double costheta = fmax(0.0, normal.dot(direction * -1));

    Vector3 radiance = color * intensity * costheta;

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 DirectionalLight::sample(Vector3 point, Vector3 normal, Vector3 view, Scene& scene) const {
    // Shadow ray check
    Vector3 shadow_direction = direction * -1;
    Vector3 inv_shadow = 1 / shadow_direction;
    point += normal * 0.001;
    CollisionInfo shadow = scene.intersectRay(point, shadow_direction, inv_shadow);
    if (shadow.hit) return Vector3();

    Vector3 radiance = color * intensity;

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 SphereLight::sample(Vector3 point, Vector3 normal, Scene& scene) const {
    if (position != last_position || radius != last_radius) {
        sphere = Sphere(position, radius);
        last_position = position;
        last_radius = radius;
        surface_area = sphere.surfaceArea();
    }

    if (!rng) throw std::runtime_error("Tried to sample sphere light, but the RNG is not assigned yet");
    Vector3 random_light_position = Vector3(0, 0, 0);
    random_light_position.z = 2.0 * rng->random_float() - 1.0;
    double theta = 2.0 * M_PI * rng->random_float();

    double r = sqrt(1 - pow(random_light_position.z, 2));
    random_light_position.x = r * cos(theta);
    random_light_position.y = r * sin(theta);
    random_light_position *= radius;
    random_light_position += position;

    Vector3 light_vec = random_light_position - point;
    float dist2 = light_vec.dot(light_vec);

    // Avoid division by zero
    if (dist2 < 1e-6f) return Vector3();

    float dist = std::sqrt(dist2);
    Vector3 L = light_vec / dist;

    // Cosine term
    float NdotL = normal.dot(L);
    if (NdotL <= 0.0f) return Vector3();

    // Light cosine
    Vector3 light_normal = (random_light_position - position).normalize();
    float cos_light = light_normal.dot(-L);
    if (cos_light <= 0.0f) return Vector3();

    // Shadow ray
    Vector3 origin = point + L * 1e-4f;
    Vector3 inv_L = 1 / L;
    CollisionInfo shadow = scene.intersectRay(origin, L, inv_L);
    if (shadow.hit && shadow.distance < dist) return Vector3();

    // Inverse square falloff
    Vector3 radiance = color * intensity * NdotL * (cos_light / dist2);
    radiance *= surface_area;

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 SphereLight::sample(Vector3 point, Vector3 normal, Vector3 view, Scene& scene) const {
    if (position != last_position || radius != last_radius) {
        sphere = Sphere(position, radius);
        last_position = position;
        last_radius = radius;
        surface_area = sphere.surfaceArea();
    }

    // Reflection
    Vector3 reflected = view - normal * 2.0 * view.dot(normal);
    Vector3 inv_reflected = 1 / reflected;
    Vector3 origin = point + reflected * 1e-4f;

    CollisionInfo sphere_collision = sphere.collide_ray(origin, reflected, inv_reflected);
    if (!sphere_collision.hit) return Vector3();

    CollisionInfo shadow = scene.intersectRay(origin, reflected, inv_reflected);
    if (shadow.hit && shadow.distance < sphere_collision.distance) return Vector3();

    double costheta = fmax(0, normal.dot(reflected));

    // Inverse square falloff
    Vector3 radiance = color * intensity * (costheta / pow(sphere_collision.distance, 2));

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 BoxLight::sample(Vector3 point, Vector3 normal, Scene& scene) const {
    if (last_halfsize != halfsize || last_position != position || last_rotation != rotation) {
        box = Box(position, halfsize, rotation);
        Vector3 zero = Vector3();
        Vector3 right = Vector3(1, 0, 0);
        box.collide_ray(zero, right, right);
        last_halfsize = halfsize;
        last_position = position;
        last_rotation = rotation;
        surface_area = box.surfaceArea();
    }

    if (!rng) throw std::runtime_error("Tried to sample box light, but the RNG is not assigned yet");

    const float hx = halfsize.x;
    const float hy = halfsize.y;
    const float hz = halfsize.z;

    const double face_area_posx = 4.0 * hy * hz; // +X
    const double face_area_posy = 4.0 * hx * hz; // +Y
    const double face_area_posz = 4.0 * hx * hy; // +Z

    const double area_pair_x = face_area_posx * 2.0;
    const double area_pair_y = face_area_posy * 2.0;
    const double area_pair_z = face_area_posz * 2.0;

    const double total_area = area_pair_x + area_pair_y + area_pair_z;
    if (total_area <= 0.0) return Vector3();

    double r = rng->random_float() * total_area;

    Vector3 random_light_position;
    Vector3 light_normal;

    if (r < area_pair_x) {
        bool positive = rng->random_float() < 0.5f;
        float x = positive ? hx : -hx;
        float y = (rng->random_float() * 2.0f - 1.0f) * hy;
        float z = (rng->random_float() * 2.0f - 1.0f) * hz;
        random_light_position = Vector3(x, y, z);
        light_normal = Vector3(positive * 2 - 1, 0, 0);
    } else if (r < area_pair_x + area_pair_y) {
        bool positive = rng->random_float() < 0.5f;
        float y = positive ? hy : -hy;
        float x = (rng->random_float() * 2.0f - 1.0f) * hx;
        float z = (rng->random_float() * 2.0f - 1.0f) * hz;
        random_light_position = Vector3(x, y, z);
        light_normal = Vector3(0, positive * 2 - 1, 0);
    } else {
        bool positive = rng->random_float() < 0.5f;
        float z = positive ? hz : -hz;
        float x = (rng->random_float() * 2.0f - 1.0f) * hx;
        float y = (rng->random_float() * 2.0f - 1.0f) * hy;
        random_light_position = Vector3(x, y, z);
        light_normal = Vector3(0, 0, positive * 2 - 1);
    }
    
    Vector3* rotation_matrix = box.get_rotation_matrix();
    random_light_position = Vector3(
        rotation_matrix[0].dot(random_light_position),
        rotation_matrix[1].dot(random_light_position),
        rotation_matrix[2].dot(random_light_position)
    );
    light_normal = Vector3(
        rotation_matrix[0].dot(light_normal),
        rotation_matrix[1].dot(light_normal),
        rotation_matrix[2].dot(light_normal)
    );

    random_light_position += position;

    Vector3 light_vec = random_light_position - point;
    float dist2 = light_vec.dot(light_vec);
    if (dist2 < 1e-6f) return Vector3();

    float dist = std::sqrt(dist2);
    Vector3 L = light_vec / dist;
    Vector3 inv_L = 1 / L;

    float NdotL = normal.dot(L);
    if (NdotL <= 0.0f) return Vector3();

    float cos_light = light_normal.dot(-L);
    if (cos_light <= 0.0f) return Vector3();

    // Shadow ray (offset along normal to avoid self-intersection)
    Vector3 origin = point + normal * 0.001;
    CollisionInfo shadow = scene.intersectRay(origin, L, inv_L);
    if (shadow.hit && shadow.distance < dist) return Vector3();

    Vector3 radiance = color * intensity * NdotL * (cos_light / dist2);
    radiance *= surface_area;

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}

Vector3 BoxLight::sample(Vector3 point, Vector3 normal, Vector3 view, Scene& scene) const {
    if (last_halfsize != halfsize || last_position != position || last_rotation != rotation) {
        box = Box(position, halfsize, rotation);
        Vector3 zero = Vector3();
        Vector3 right = Vector3(1, 0, 0);
        box.collide_ray(zero, right, right);
        last_halfsize = halfsize;
        last_position = position;
        last_rotation = rotation;
        surface_area = box.surfaceArea();
    }

    Vector3 reflected = view - normal * 2.0 * view.dot(normal);
    Vector3 inv_reflected = 1 / reflected;

    Vector3 origin = point + reflected * 1e-4f;
    CollisionInfo box_collision = box.collide_ray(origin, reflected, inv_reflected);
    if (!box_collision.hit) return Vector3();

    CollisionInfo shadow = scene.intersectRay(origin, reflected, inv_reflected);
    if (shadow.hit && shadow.distance < box_collision.distance) return Vector3();

    double costheta = fmax(0, normal.dot(reflected));

    // Inverse square falloff
    Vector3 radiance = color * intensity * (costheta / pow(box_collision.distance, 2));

    if (!std::isfinite(radiance.x) || !std::isfinite(radiance.y) || !std::isfinite(radiance.z)) return Vector3();

    return radiance;
}