bvh.h

#pragma once
 
#include <limits>
#include <memory>
#include <vector>
 
#include <cgv/math/fray.h>
#include <cgv/math/fvec.h>
#include <cgv/media/axis_aligned_box.h>
 
#include "lib_begin.h"
 
namespace cgv {
namespace data {
 
struct ray_intersection_info {
    float t = std::numeric_limits<float>::max();
    cgv::vec3 normal;
    cgv::vec2 uv;
};
 
class ray_intersectable {
public:
    ray_intersectable() {}
    virtual ~ray_intersectable() {}
 
    virtual cgv::box3 get_bounds() const = 0;
 
    virtual bool intersect(const cgv::ray3& ray, ray_intersection_info& info) const = 0;
};
 
struct bvh_node {
    cgv::box3 bounds = {};
    std::vector<size_t> primitive_indices;
    std::unique_ptr<bvh_node> child_a;
    std::unique_ptr<bvh_node> child_b;
};
 
struct bvh_result {
    bool is_hit = false;
    ray_intersection_info intersection;
    size_t primitive_index = std::numeric_limits<size_t>::max();
    const ray_intersectable* primitive = nullptr;
};
 
class CGV_API bvh {
public:
    void build(const std::vector<const ray_intersectable*>& primitives, size_t max_depth = 8);
 
    bvh_result closest_intersection(const cgv::ray3& ray) const;
 
private:
    // Keep a list of primitives inside the hierarchy. The nodes contain indices that point to this list.
    std::vector<const ray_intersectable*> _primitives;
    int _max_depth = 8;
    std::unique_ptr<bvh_node> _root = std::make_unique<bvh_node>();
 
    void split(bvh_node* node, int depth = 0);
};
 
} // namespace data
} // namespace cgv
 
#include <cgv/config/lib_end.h>