frustum.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <glm/glm.hpp>
 
namespace lmgl {
 
namespace scene {

struct AABB {
    glm::vec3 min;

    glm::vec3 max;

    AABB() : min(glm::vec3(0.0f)), max(glm::vec3(0.0f)) {}

    AABB(const glm::vec3 &min, const glm::vec3 &max) : min(min), max(max) {}

    inline glm::vec3 get_center() const { return (min + max) * 0.5f; }

    inline glm::vec3 get_extents() const { return (max - min) * 0.5f; }

    AABB transform(const glm::mat4 &matrix) const;

    void expand(const glm::vec3 &point);

    void merge(const AABB &other);
};

struct BoundingSphere {
    glm::vec3 center;

    float radius;

    BoundingSphere() : center(glm::vec3(0.0f)), radius(0.0f) {}

    BoundingSphere(const glm::vec3 &center, float radius) : center(center), radius(radius) {}

    static BoundingSphere from_aabb(const AABB &aabb);

    BoundingSphere transform(const glm::mat4 &matrix) const;
};

struct Plane {
    glm::vec3 normal;

    float distance;

    Plane() : normal(glm::vec3(0.0f, 1.0f, 0.0f)), distance(0.0f) {}

    Plane(const glm::vec3 &normal, float distance) : normal(normal), distance(distance) {}

    Plane(const glm::vec3 &point, const glm::vec3 &normal)
        : normal(glm::normalize(normal)), distance(glm::dot(this->normal, point)) {}

    inline float distance_to_point(const glm::vec3 &point) const { return glm::dot(normal, point) - distance; }

    void normalize();
};

class Frustum {
  public:
    enum PlaneIndex { Left = 0, Right, Bottom, Top, Near, Far };

    void update(const glm::mat4 &view_projection);

    bool contains_point(const glm::vec3 &point) const;

    bool contains_sphere(const BoundingSphere &sphere) const;

    bool contains_aabb(const AABB &aabb) const;

    inline const Plane &get_plane(PlaneIndex index) const { return m_planes[index]; }
 
  private:
    std::array<Plane, 6> m_planes;
};
 
} // namespace scene
 
} // namespace lmgl