view-frustum.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_GEOM_PRIMITIVES_VIEW_FRUSTUM_HPP
#define ANTKEEPER_GEOM_PRIMITIVES_VIEW_FRUSTUM_HPP
 
#include <engine/math/vector.hpp>
#include <engine/math/matrix.hpp>
#include <engine/geom/primitives/plane.hpp>
#include <engine/geom/primitives/box.hpp>
#include <engine/geom/primitives/sphere.hpp>
 
namespace geom {
namespace primitives {
 
template <class T>
struct view_frustum
{
    using vector_type = math::vec3<T>;
    
    using plane_type = geom::plane<T>;
    
    using matrix_type = math::mat4<T>;
    
    using box_type = geom::box<T>;
    
    using sphere_type = geom::sphere<T>;
    
    constexpr view_frustum() noexcept = default;
    
    inline explicit constexpr view_frustum(const matrix_type& matrix) noexcept
    {
        extract(matrix);
    }
    
    [[nodiscard]] inline constexpr const plane_type& left() const noexcept
    {
        return planes[0];
    }
    [[nodiscard]] inline constexpr plane_type& left() noexcept
    {
        return planes[0];
    }
    
    [[nodiscard]] inline constexpr const plane_type& right() const noexcept
    {
        return planes[1];
    }
    [[nodiscard]] inline constexpr plane_type& right() noexcept
    {
        return planes[1];
    }
    
    [[nodiscard]] inline constexpr const plane_type& bottom() const noexcept
    {
        return planes[2];
    }
    [[nodiscard]] inline constexpr plane_type& bottom() noexcept
    {
        return planes[2];
    }
    
    [[nodiscard]] inline constexpr const plane_type& top() const noexcept
    {
        return planes[3];
    }
    [[nodiscard]] inline constexpr plane_type& top() noexcept
    {
        return planes[3];
    }
    
    [[nodiscard]] inline constexpr const plane_type& near() const noexcept
    {
        return planes[4];
    }
    [[nodiscard]] inline constexpr plane_type& near() noexcept
    {
        return planes[4];
    }
    
    [[nodiscard]] inline constexpr const plane_type& far() const noexcept
    {
        return planes[5];
    }
    [[nodiscard]] inline constexpr plane_type& far() noexcept
    {
        return planes[5];
    }
    
    void extract(const matrix_type& matrix) noexcept
    {
        for (std::size_t i = 0; i < 6; ++i)
        {
            plane_type& plane = planes[i];      
            const std::size_t j = i >> 1;
            
            // Extract plane coefficients
            if (i % 2)
            {
                plane.normal.x()   = matrix[0][3] - matrix[0][j];
                plane.normal.y()   = matrix[1][3] - matrix[1][j];
                plane.normal.z()   = matrix[2][3] - matrix[2][j];
                plane.constant     = matrix[3][3] - matrix[3][j];
            }
            else
            {
                plane.normal.x()   = matrix[0][3] + matrix[0][j];
                plane.normal.y()   = matrix[1][3] + matrix[1][j];
                plane.normal.z()   = matrix[2][3] + matrix[2][j];
                plane.constant     = matrix[3][3] + matrix[3][j];
            }
            
            // Normalize plane coefficients
            const T inv_length = math::inv_length(plane.normal);
            plane.normal *= inv_length;
            plane.constant *= inv_length;
        }
    }
    
    [[nodiscard]] bool intersects(const box_type& box) const noexcept
    {
        for (const auto& plane: planes)
        {
            const vector_type p
            {
                (plane.normal.x() > T{0}) ? box.max.x() : box.min.x(),
                (plane.normal.y() > T{0}) ? box.max.y() : box.min.y(),
                (plane.normal.z() > T{0}) ? box.max.z() : box.min.z()
            };
            
            if (plane.distance(p) < T{0})
            {
                return false;
            }
        }
        
        return true;
    }
    
    [[nodiscard]] bool intersects(const sphere_type& sphere) const noexcept
    {
        for (const auto& plane: planes)
        {
            if (plane.distance(sphere.center) < -sphere.radius)
            {
                return false;
            }
        }
        
        return true;
    }
    
    [[nodiscard]] constexpr bool contains(const vector_type& point) const noexcept
    {
        for (const auto& plane: planes)
        {
            if (plane.distance(point) < T{0})
            {
                return false;
            }
        }
        
        return true;
    }
    
    [[nodiscard]] bool contains(const box_type& box) const noexcept
    {
        for (const auto& plane: planes)
        {
            const vector_type p
            {
                (plane.normal.x() > T{0}) ? box.max.x() : box.min.x(),
                (plane.normal.y() > T{0}) ? box.max.y() : box.min.y(),
                (plane.normal.z() > T{0}) ? box.max.z() : box.min.z()
            };
            
            const vector_type n
            {
                (plane.normal.x() < T{0}) ? box.max.x() : box.min.x(),
                (plane.normal.y() < T{0}) ? box.max.y() : box.min.y(),
                (plane.normal.z() < T{0}) ? box.max.z() : box.min.z()
            };
        
            if (plane.distance(p) < T{0} || plane.distance(n) < T{0})
            {
                return false;
            }
        }
        
        return true;
    }
    
    [[nodiscard]] bool contains(const sphere_type& sphere) const noexcept
    {
        for (const auto& plane: planes)
        {
            if (plane.distance(sphere.center) < sphere.radius)
            {
                return false;
            }
        }
        
        return true;
    }
    
    plane_type planes[6];
};
 
} // namespace primitives
 
using namespace primitives;
 
} // namespace geom
 
#endif // ANTKEEPER_GEOM_PRIMITIVES_VIEW_FRUSTUM_HPP