frustum.cpp

Go to the documentation of this file.

#include "frustum.h"
 
namespace math
{
namespace
{
 
auto get_transformed_bbox_vertices(const bbox& AABB, const transform& t) -> std::array<vec3, 8>
{
    std::array<vec3, 8> vertices;
 
    vec3 min = AABB.min;
    vec3 max = AABB.max;
 
    vertices[0] = t.transform_coord(vec3(min.x, min.y, min.z));
    vertices[1] = t.transform_coord(vec3(max.x, min.y, min.z));
    vertices[2] = t.transform_coord(vec3(min.x, max.y, min.z));
    vertices[3] = t.transform_coord(vec3(max.x, max.y, min.z));
    vertices[4] = t.transform_coord(vec3(min.x, min.y, max.z));
    vertices[5] = t.transform_coord(vec3(max.x, min.y, max.z));
    vertices[6] = t.transform_coord(vec3(min.x, max.y, max.z));
    vertices[7] = t.transform_coord(vec3(max.x, max.y, max.z));
 
    return vertices;
}
 
} // namespace
 
frustum::frustum()
{
    // Initialize values
    planes.fill(vec4(0.0f, 0.0f, 0.0f, 0.0f));
    points.fill(vec3(0.0f, 0.0f, 0.0f));
    position = vec3(0, 0, 0);
}
 
frustum::frustum(const transform& View, const transform& Proj, bool homogeneousDepth)
{
    update(View, Proj, homogeneousDepth);
}
 
frustum::frustum(const bbox& AABB)
{
    // Compute planes
    planes[volume_plane::left] = AABB.get_plane(volume_plane::left);
    planes[volume_plane::right] = AABB.get_plane(volume_plane::right);
    planes[volume_plane::top] = AABB.get_plane(volume_plane::top);
    planes[volume_plane::bottom] = AABB.get_plane(volume_plane::bottom);
    planes[volume_plane::near_plane] = AABB.get_plane(volume_plane::near_plane);
    planes[volume_plane::far_plane] = AABB.get_plane(volume_plane::far_plane);
 
    // Compute points
    vec3 e = AABB.get_extents();
    vec3 p = AABB.get_center();
    points[volume_geometry_point::left_bottom_near] = vec3(p.x - e.x, p.y - e.y, p.z + e.z);
    points[volume_geometry_point::left_bottom_far] = vec3(p.x - e.x, p.y - e.y, p.z + e.z);
    points[volume_geometry_point::right_bottom_near] = vec3(p.x + e.x, p.y - e.y, p.z - e.z);
    points[volume_geometry_point::right_bottom_far] = vec3(p.x + e.x, p.y - e.y, p.z + e.z);
    points[volume_geometry_point::left_top_near] = vec3(p.x - e.x, p.y + e.y, p.z + e.z);
    points[volume_geometry_point::left_top_far] = vec3(p.x - e.x, p.y + e.y, p.z + e.z);
    points[volume_geometry_point::right_top_near] = vec3(p.x + e.x, p.y + e.y, p.z - e.z);
    points[volume_geometry_point::right_top_far] = vec3(p.x + e.x, p.y + e.y, p.z + e.z);
    position = p;
}
 
void frustum::update(const transform& view, const transform& proj, bool homogeneousDepth)
{
    // Build a combined view & projection matrix
    const transform m = proj * view;
 
    // Extract frustum planes from matrix
    // Planes are in format: normal(xyz), offset(w)
    // Expects left handed orientation and row_major matrix layout
    planes[volume_plane::right].data.x = m[0][3] + m[0][0];
    planes[volume_plane::right].data.y = m[1][3] + m[1][0];
    planes[volume_plane::right].data.z = m[2][3] + m[2][0];
    planes[volume_plane::right].data.w = m[3][3] + m[3][0];
 
    planes[volume_plane::left].data.x = m[0][3] - m[0][0];
    planes[volume_plane::left].data.y = m[1][3] - m[1][0];
    planes[volume_plane::left].data.z = m[2][3] - m[2][0];
    planes[volume_plane::left].data.w = m[3][3] - m[3][0];
 
    planes[volume_plane::top].data.x = m[0][3] - m[0][1];
    planes[volume_plane::top].data.y = m[1][3] - m[1][1];
    planes[volume_plane::top].data.z = m[2][3] - m[2][1];
    planes[volume_plane::top].data.w = m[3][3] - m[3][1];
 
    planes[volume_plane::bottom].data.x = m[0][3] + m[0][1];
    planes[volume_plane::bottom].data.y = m[1][3] + m[1][1];
    planes[volume_plane::bottom].data.z = m[2][3] + m[2][1];
    planes[volume_plane::bottom].data.w = m[3][3] + m[3][1];
 
    planes[volume_plane::far_plane].data.x = m[0][3] - m[0][2];
    planes[volume_plane::far_plane].data.y = m[1][3] - m[1][2];
    planes[volume_plane::far_plane].data.z = m[2][3] - m[2][2];
    planes[volume_plane::far_plane].data.w = m[3][3] - m[3][2];
 
    if(homogeneousDepth)
    {
        planes[volume_plane::near_plane].data.x = m[0][3] + m[0][2];
        planes[volume_plane::near_plane].data.y = m[1][3] + m[1][2];
        planes[volume_plane::near_plane].data.z = m[2][3] + m[2][2];
        planes[volume_plane::near_plane].data.w = m[3][3] + m[3][2];
    }
    else
    {
        planes[volume_plane::near_plane].data.x = m[0][2];
        planes[volume_plane::near_plane].data.y = m[1][2];
        planes[volume_plane::near_plane].data.z = m[2][2];
        planes[volume_plane::near_plane].data.w = m[3][2];
    }
 
    for(auto& plane : planes)
    {
        plane.data *= -1.0f;
    }
    // Normalize and compute additional information.
    set_planes(planes);
 
    // Compute the originating position of the frustum.
    position = vec3(view[0][0], view[1][0], view[2][0]) * -view[3][0];
    position += vec3(view[0][1], view[1][1], view[2][1]) * -view[3][1];
    position += vec3(view[0][2], view[1][2], view[2][2]) * -view[3][2];
 
    // Extract the camera forward vector (assuming left-handed and row-major)
    vec3 forward = -vec3(view[0][2], view[1][2], view[2][2]);
 
    // Compute near distance
    near_distance_ =
        (dot(vec3(planes[volume_plane::near_plane].data), position) + planes[volume_plane::near_plane].data.w) /
        dot(vec3(planes[volume_plane::near_plane].data), forward);
 
    // Compute far distance
    far_distance_ =
        (dot(vec3(planes[volume_plane::far_plane].data), position) + planes[volume_plane::far_plane].data.w) /
        dot(vec3(planes[volume_plane::far_plane].data), forward);
}
 
void frustum::set_planes(const std::array<plane, 6>& new_planes)
{
    planes = new_planes;
    // Copy and normalize the planes
    for(auto& plane : planes)
    {
        plane = plane::normalize(plane);
    }
 
    // Recompute the frustum corner points.
    recompute_points();
}
 
void frustum::recompute_points()
{
    // Compute the 8 corner points
    for(std::size_t i = 0; i < 8; ++i)
    {
        const plane& p0 =
            plane::normalize((i & 1) != 0u ? planes[volume_plane::near_plane] : planes[volume_plane::far_plane]);
        const plane& p1 = plane::normalize((i & 2) != 0u ? planes[volume_plane::top] : planes[volume_plane::bottom]);
        const plane& p2 = plane::normalize((i & 4) != 0u ? planes[volume_plane::left] : planes[volume_plane::right]);
 
        // Compute the point at which the three planes intersect
        vec3 n0(p0.data);
        vec3 n1(p1.data);
        vec3 n2(p2.data);
 
        vec3 n1_n2 = glm::cross(n1, n2);
        vec3 n2_n0 = glm::cross(n2, n0);
        vec3 n0_n1 = glm::cross(n0, n1);
 
        float cosTheta = glm::dot(n0, n1_n2);
        float secTheta = 1.0f / cosTheta;
 
        n1_n2 = n1_n2 * p0.data.w;
        n2_n0 = n2_n0 * p1.data.w;
        n0_n1 = n0_n1 * p2.data.w;
 
        points[i] = -(n1_n2 + n2_n0 + n0_n1) * secTheta;
 
    } // Next Corner
}
 
auto frustum::classify_vertices(const vec3* vertices, size_t count) const -> volume_query
{
    // Initialize the result as inside
    volume_query Result = volume_query::inside;
 
    // Loop through all the planes
    for(const auto& plane : planes)
    {
        bool allOutside = true;
        bool anyOutside = false;
 
        // Check each vertex
        for(size_t i = 0; i < count; ++i)
        {
            float distance = plane::dot_coord(plane, vertices[i]);
 
            if(distance > 0.0f)
            {
                anyOutside = true;
            }
            else
            {
                allOutside = false;
            }
        }
 
        // If all vertices are outside one plane, the OBB is outside the frustum
        if(allOutside)
        {
            return volume_query::outside;
        }
 
        // If any vertex is outside one plane, the OBB intersects the frustum
        if(anyOutside)
        {
            Result = volume_query::intersect;
        }
    }
 
    // Return the classification result
    return Result;
}
 
auto frustum::classify_aabb(const bbox& AABB) const -> volume_query
{
    volume_query result = volume_query::inside;
    vec3 nearPoint, farPoint;
 
    for(const auto& plane : planes)
    {
        nearPoint.x = plane.data.x > 0.0f ? AABB.min.x : AABB.max.x;
        farPoint.x = plane.data.x > 0.0f ? AABB.max.x : AABB.min.x;
 
        nearPoint.y = plane.data.y > 0.0f ? AABB.min.y : AABB.max.y;
        farPoint.y = plane.data.y > 0.0f ? AABB.max.y : AABB.min.y;
 
        nearPoint.z = plane.data.z > 0.0f ? AABB.min.z : AABB.max.z;
        farPoint.z = plane.data.z > 0.0f ? AABB.max.z : AABB.min.z;
 
        if(plane::dot_coord(plane, nearPoint) > 0.0f)
        {
            return volume_query::outside;
        }
 
        if(plane::dot_coord(plane, farPoint) > 0.0f)
        {
            result = volume_query::intersect;
        }
    }
 
    return result;
}
 
auto frustum::classify_obb(const bbox& AABB, const transform& t) const -> volume_query
{
    auto vertices = get_transformed_bbox_vertices(AABB, t);
    return classify_vertices(vertices.data(), vertices.size());
}
 
auto frustum::classify_aabb(const bbox& AABB, unsigned int& frustumBits, int& lastOutside) const -> volume_query
{
    volume_query result = volume_query::inside;
    vec3 nearPoint, farPoint;
 
    if(lastOutside >= 0 && ((frustumBits >> lastOutside) & 0x1) == 0x0)
    {
        const plane& plane = planes[lastOutside];
 
        nearPoint.x = plane.data.x > 0.0f ? AABB.min.x : AABB.max.x;
        farPoint.x = plane.data.x > 0.0f ? AABB.max.x : AABB.min.x;
 
        nearPoint.y = plane.data.y > 0.0f ? AABB.min.y : AABB.max.y;
        farPoint.y = plane.data.y > 0.0f ? AABB.max.y : AABB.min.y;
 
        nearPoint.z = plane.data.z > 0.0f ? AABB.min.z : AABB.max.z;
        farPoint.z = plane.data.z > 0.0f ? AABB.max.z : AABB.min.z;
 
        if(plane::dot_coord(plane, nearPoint) > 0.0f)
        {
            return volume_query::outside;
        }
 
        if(plane::dot_coord(plane, farPoint) > 0.0f)
        {
            result = volume_query::intersect;
        }
        else
        {
            frustumBits |= (0x1 << lastOutside);
        }
    }
 
    for(size_t i = 0; i < planes.size(); i++)
    {
        if(((frustumBits >> i) & 0x1) == 0x1)
            continue;
        if(lastOutside >= 0 && lastOutside == int(i))
            continue;
 
        const plane& plane = planes[i];
 
        nearPoint.x = plane.data.x > 0.0f ? AABB.min.x : AABB.max.x;
        farPoint.x = plane.data.x > 0.0f ? AABB.max.x : AABB.min.x;
 
        nearPoint.y = plane.data.y > 0.0f ? AABB.min.y : AABB.max.y;
        farPoint.y = plane.data.y > 0.0f ? AABB.max.y : AABB.min.y;
 
        nearPoint.z = plane.data.z > 0.0f ? AABB.min.z : AABB.max.z;
        farPoint.z = plane.data.z > 0.0f ? AABB.max.z : AABB.min.z;
 
        if(plane::dot_coord(plane, nearPoint) > 0.0f)
        {
            lastOutside = int(i);
            return volume_query::outside;
        }
 
        if(plane::dot_coord(plane, farPoint) > 0.0f)
        {
            result = volume_query::intersect;
        }
        else
        {
            frustumBits |= (0x1 << i);
        }
    }
 
    lastOutside = -1;
    return result;
}
 
auto frustum::test_aabb(const bbox& AABB) const -> bool
{
    // Loop through all the planes
    vec3 nearPoint;
    for(const auto& plane : planes)
    {
        nearPoint.x = plane.data.x > 0.0f ? AABB.min.x : AABB.max.x;
        nearPoint.y = plane.data.y > 0.0f ? AABB.min.y : AABB.max.y;
        nearPoint.z = plane.data.z > 0.0f ? AABB.min.z : AABB.max.z;
 
        // If near extreme point is outside, then the AABB is totally outside the
        // frustum
        if(plane::dot_coord(plane, nearPoint) > 0.0f)
        {
            return false;
        }
 
    } // Next plane
 
    // Intersecting / inside
    return true;
}
 
auto frustum::test_vertices(const vec3* vertices, size_t vert_count) const -> bool
{
    for(const auto& plane : planes)
    {
        bool allOutside = true;
 
        for(size_t i = 0; i < vert_count; ++i)
        {
            if(plane::dot_coord(plane, vertices[i]) <= 0.0f)
            {
                // If any vertex is inside or on the plane, we are not all outside
                allOutside = false;
                break;
            }
        }
 
        // If all vertices are outside this plane, the vertices are outside the frustum
        if(allOutside)
        {
            return false;
        }
    }
 
    // If none of the planes had all vertices outside, the vertices are inside or intersecting
    return true;
}
 
auto frustum::test_obb(const bbox& AABB, const transform& t) const -> bool
{
    auto vertices = get_transformed_bbox_vertices(AABB, t);
    return test_vertices(vertices.data(), vertices.size());
}
 
auto frustum::classify_sphere(const bsphere& sphere) const -> volume_query
{
    volume_query Result = volume_query::inside;
 
    // Test frustum planes
    for(const auto& plane : planes)
    {
        float fDot = plane::dot_coord(plane, sphere.position);
 
        // Sphere entirely in front of plane
        if(fDot >= sphere.radius)
        {
            return volume_query::outside;
        }
 
        // Sphere spans plane
        if(fDot >= -sphere.radius)
        {
            Result = volume_query::intersect;
        }
 
    } // Next plane
 
    // Return the result
    return Result;
}
 
auto frustum::test_sphere(const bsphere& sphere) const -> bool
{
    // Test frustum planes
    for(const auto& plane : planes)
    {
        float fDot = plane::dot_coord(plane, sphere.position);
 
        // Sphere entirely in front of plane
        if(fDot >= sphere.radius)
        {
            return false;
        }
 
    } // Next plane
 
    // Intersects
    return true;
}
 
auto frustum::test_sphere(const bsphere& sphere, const transform& t) const -> bool
{
    return test_sphere(bsphere(t.transform_coord(sphere.position), sphere.radius));
}
 
auto frustum::swept_sphere_intersect_plane(float& t0,
                                           float& t1,
                                           const plane& plane,
                                           const bsphere& sphere,
                                           const vec3& vecSweepDirection) -> bool
{
    float b_dot_n = plane::dot_coord(plane, sphere.position);
    float d_dot_n = plane::dot_normal(plane, vecSweepDirection);
 
    if(d_dot_n == 0.0f)
    {
        if(b_dot_n <= sphere.radius)
        {
            //  Effectively infinity
            t0 = 0.0f;
            t1 = std::numeric_limits<float>::max();
            return true;
 
        } // End if infinity
 
        return false;
 
    } // End if runs parallel to plane
 
    // Compute the two possible intersections
    float tmp0 = (sphere.radius - b_dot_n) / d_dot_n;
    float tmp1 = (-sphere.radius - b_dot_n) / d_dot_n;
    t0 = glm::min<float>(tmp0, tmp1);
    t1 = glm::max<float>(tmp0, tmp1);
    return true;
 
    // End if intersection
}
 
auto frustum::test_swept_sphere(const bsphere& sphere, const vec3& vecSweepDirection, float max_distance) const -> bool
{
    if(test_sphere(sphere))
    {
        return true;
    }
 
    // Robust swept-sphere vs convex frustum test using interval intersection.
    // Plane convention in this engine:
    // - plane::dot_coord(plane, point) > 0 means point is outside/in-front of the plane
    // - inside is <= 0
    //
    // A sphere of radius r intersects the frustum iff for every plane:
    //     dot_coord(plane, center(t)) <= r
    // where center(t) = center0 + dir * t.
    //
    // NOTE: max_distance is only meaningful if vecSweepDirection is normalized.
    constexpr float sweep_parallel_epsilon = 1e-6f;
    const float radius_tolerance = sphere.radius * 1.1f;
 
    float t_enter = 0.0f;
    float t_exit = (max_distance < 0.0f) ? std::numeric_limits<float>::infinity() : max_distance;
 
    for(const auto& plane : planes)
    {
        const float b_dot_n = plane::dot_coord(plane, sphere.position);
        const float d_dot_n = plane::dot_normal(plane, vecSweepDirection);
 
        // Constraint: b_dot_n + d_dot_n * t <= radius_tolerance
        if(glm::abs(d_dot_n) < sweep_parallel_epsilon)
        {
            // Moving parallel to this plane: either always satisfies, or never satisfies.
            if(b_dot_n > radius_tolerance)
            {
                return false;
            }
            continue;
        }
 
        const float t_bound = (radius_tolerance - b_dot_n) / d_dot_n;
        if(d_dot_n > 0.0f)
        {
            // Increasing distance to plane as t increases -> upper bound on t.
            t_exit = glm::min(t_exit, t_bound);
        }
        else
        {
            // Decreasing distance to plane as t increases -> lower bound on t.
            t_enter = glm::max(t_enter, t_bound);
        }
 
        if(t_enter > t_exit)
        {
            return false;
        }
    }
 
    return t_exit >= 0.0f;
}
 
auto frustum::test_swept_aabb(const bbox& box, const vec3& vecSweepDirection, float max_distance) const -> bool
{
    // Early out: if box already intersects frustum
    if(test_aabb(box))
    {
        return true;
    }
 
    // Robust swept-AABB vs convex frustum test using interval intersection.
    // For each plane, we find the "support vertex" (corner furthest in direction of plane normal)
    // and compute when that vertex enters/exits the plane's half-space during the sweep.
    //
    // NOTE: max_distance is only meaningful if vecSweepDirection is normalized.
    constexpr float sweep_parallel_epsilon = 1e-6f;
 
    float t_enter = 0.0f;
    float t_exit = (max_distance < 0.0f) ? std::numeric_limits<float>::infinity() : max_distance;
 
    for(const auto& plane : planes)
    {
        // Get plane normal
        const vec3 normal(plane.data.x, plane.data.y, plane.data.z);
        
        // Find the NEAR corner: corner of AABB closest to the plane
        // This is the critical corner - if it's inside, the whole box can be inside
        // Use same logic as classify_aabb (line 234)
        vec3 near_corner(
            (normal.x >= 0.0f) ? box.min.x : box.max.x,
            (normal.y >= 0.0f) ? box.min.y : box.max.y,
            (normal.z >= 0.0f) ? box.min.z : box.max.z
        );
 
        const float b_dot_n = plane::dot_coord(plane, near_corner);
        const float d_dot_n = plane::dot_normal(plane, vecSweepDirection);
 
        // Constraint: b_dot_n + d_dot_n * t <= 0 (near corner must be inside plane)
        if(glm::abs(d_dot_n) < sweep_parallel_epsilon)
        {
            // Moving parallel to this plane: either always satisfies, or never satisfies.
            if(b_dot_n > 0.0f)
            {
                return false; // Near corner outside, whole box never enters
            }
            continue;
        }
 
        const float t_bound = -b_dot_n / d_dot_n;
        if(d_dot_n > 0.0f)
        {
            // Near corner moving away from inside → upper bound on t.
            t_exit = glm::min(t_exit, t_bound);
        }
        else
        {
            // Near corner moving toward inside → lower bound on t.
            t_enter = glm::max(t_enter, t_bound);
        }
 
        if(t_enter > t_exit)
        {
            return false; // No valid interval
        }
    }
 
    return t_exit >= 0.0f;
}
 
auto frustum::test_point(const vec3& vecPoint) const -> bool
{
    return test_sphere(bsphere(vecPoint, 0.0f));
}
 
auto frustum::test_line(const vec3& v1, const vec3& v2) const -> bool
{
    int nCode1 = 0, nCode2 = 0;
    float fDist1, fDist2, t;
    int nSide1, nSide2;
    vec3 vDir, vIntersect;
    unsigned int i;
 
    // Test each plane
    for(i = 0; i < 6; ++i)
    {
        // Classify each point of the line against the plane.
        fDist1 = plane::dot_coord(planes[i], v1);
        fDist2 = plane::dot_coord(planes[i], v2);
        nSide1 = (fDist1 >= 0) ? 1 : 0;
        nSide2 = (fDist2 >= 0) ? 1 : 0;
 
        // Accumulate the classification info to determine
        // if the edge was spanning any of the planes.
        nCode1 |= (nSide1 << i);
        nCode2 |= (nSide2 << i);
 
        // If the line is completely in front of any plane
        // then it cannot possibly be intersecting.
        if(nSide1 == 1 && nSide2 == 1)
        {
            return false;
        }
 
        // The line is potentially spanning?
        if((nSide1 ^ nSide2) != 0)
        {
            // Compute the point at which the line intersects this plane.
            vDir = v2 - v1;
            t = -plane::dot_coord(planes[i], v1) / plane::dot_normal(planes[i], vDir);
 
            // Truly spanning?
            if((t >= 0.0f) && (t <= 1.0f))
            {
                vIntersect = v1 + (vDir * t);
                if(test_sphere(bsphere(vIntersect, 0.01f)))
                {
                    return true;
                }
 
            } // End if spanning
 
        } // End if different sides
 
    } // Next plane
 
    // Intersecting?
    return (nCode1 == 0) || (nCode2 == 0);
}
 
auto frustum::classify_plane(const plane& plane) const -> volume_query
{
    unsigned int nInFrontCount = 0;
    unsigned int nBehindCount = 0;
 
    // Test frustum points
    for(unsigned int i = 0; i < 8; ++i)
    {
        float fDot = plane::dot_coord(plane, points[i]);
        if(fDot > 0.0f)
        {
            nInFrontCount++;
        }
        else if(fDot < 0.0f)
        {
            nBehindCount++;
        }
 
    } // Next plane
 
    // frustum entirely in front of plane
    if(nInFrontCount == 8)
    {
        return volume_query::outside;
    }
 
    // frustum entire behind plane
    if(nBehindCount == 8)
    {
        return volume_query::inside;
    }
 
    // Return intersection (spanning the plane)
    return volume_query::intersect;
}
 
auto frustum::test_frustum(const frustum& f) const -> bool
{
    // clang-format off
    // A -> B
    bool bIntersect1 =
        test_line(f.points[volume_geometry_point::left_bottom_far],
                  f.points[volume_geometry_point::left_bottom_near]) ||
        test_line(f.points[volume_geometry_point::left_bottom_near],
                  f.points[volume_geometry_point::right_bottom_near]) ||
        test_line(f.points[volume_geometry_point::right_bottom_near],
                  f.points[volume_geometry_point::right_bottom_far]) ||
        test_line(f.points[volume_geometry_point::right_bottom_far],
                  f.points[volume_geometry_point::left_bottom_far]) ||
        test_line(f.points[volume_geometry_point::right_bottom_far],
                  f.points[volume_geometry_point::right_top_far]) ||
        test_line(f.points[volume_geometry_point::right_bottom_near],
                  f.points[volume_geometry_point::right_top_near]) ||
        test_line(f.points[volume_geometry_point::left_bottom_far],
                  f.points[volume_geometry_point::left_top_far]) ||
        test_line(f.points[volume_geometry_point::left_bottom_near],
                  f.points[volume_geometry_point::left_top_near]) ||
        test_line(f.points[volume_geometry_point::left_top_near],
                  f.points[volume_geometry_point::left_top_far]) ||
        test_line(f.points[volume_geometry_point::left_top_far],
                  f.points[volume_geometry_point::right_top_far]) ||
        test_line(f.points[volume_geometry_point::right_top_far],
                  f.points[volume_geometry_point::right_top_near]) ||
        test_line(f.points[volume_geometry_point::right_top_near],
                  f.points[volume_geometry_point::left_top_near]);
    // clang-format on
 
    // Early out
    if(bIntersect1)
    {
        return true;
    }
 
    // clang-format off
    // B -> A
    bool bIntersect2 =
        f.test_line(points[volume_geometry_point::left_bottom_far],
                    points[volume_geometry_point::left_bottom_near]) ||
        f.test_line(points[volume_geometry_point::left_bottom_near],
                    points[volume_geometry_point::right_bottom_near]) ||
        f.test_line(points[volume_geometry_point::right_bottom_near],
                    points[volume_geometry_point::right_bottom_far]) ||
        f.test_line(points[volume_geometry_point::right_bottom_far],
                    points[volume_geometry_point::left_bottom_far]) ||
        f.test_line(points[volume_geometry_point::right_bottom_far],
                    points[volume_geometry_point::left_top_far]) ||
        f.test_line(points[volume_geometry_point::right_bottom_near],
                    points[volume_geometry_point::right_top_near]) ||
        f.test_line(points[volume_geometry_point::left_bottom_far],
                    points[volume_geometry_point::left_top_far]) ||
        f.test_line(points[volume_geometry_point::left_bottom_near],
                    points[volume_geometry_point::left_top_near]) ||
        f.test_line(points[volume_geometry_point::left_top_near],
                    points[volume_geometry_point::left_top_far]) ||
        f.test_line(points[volume_geometry_point::left_top_far],
                    points[volume_geometry_point::right_top_near]) ||
        f.test_line(points[volume_geometry_point::right_top_far],
                    points[volume_geometry_point::right_top_near]) ||
        f.test_line(points[volume_geometry_point::right_top_near],
                    points[volume_geometry_point::left_top_near]);
    // clang-format on
 
    // Return intersection result
    return bIntersect2;
}
 
auto frustum::mul(const transform& mtx) -> frustum&
{
    auto mtxIT = transpose(inverse(mtx.get_matrix()));
 
    // transform planes
    for(auto& plane : planes)
    {
        plane = plane::normalize(plane::mul(plane, mtxIT));
    }
 
    // transform points
    for(auto& point : points)
    {
        point = mtx.transform_coord(point);
    }
 
    // transform originating position.
    position = mtx.transform_coord(position);
 
    // Return reference to self.
    return *this;
}
 
auto frustum::operator==(const frustum& frustum) const -> bool
{
    // Compare planes.
    for(size_t i = 0; i < planes.size(); ++i)
    {
        const plane& p1 = planes[i];
        const plane& p2 = frustum.planes[i];
        if(!(glm::abs<float>(p1.data.x - p2.data.x) <= glm::epsilon<float>() &&
             glm::abs<float>(p1.data.y - p2.data.y) <= glm::epsilon<float>() &&
             glm::abs<float>(p1.data.z - p2.data.z) <= glm::epsilon<float>() &&
             glm::abs<float>(p1.data.w - p2.data.w) <= glm::epsilon<float>()))
        {
            return false;
        }
 
    } // Next plane
 
    // Match
    return true;
}
} // namespace math