ImathFrustumTest.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// A viewing frustum class
//
// This file contains algorithms applied to or in conjunction with
// Frustum visibility testing (Imath::Frustum).
//
// Methods for frustum-based rejection of primitives are contained here.
//
 
#ifndef INCLUDED_ATOMSMATHFRUSTUMTEST_H
#define INCLUDED_ATOMSMATHFRUSTUMTEST_H
 
#include <AtomsMath/ImathBox.h>
#include <AtomsMath/ImathFrustum.h>
#include <AtomsMath/ImathMatrix.h>
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathSphere.h>
#include <AtomsMath/ImathVec.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class FrustumTest
{
  public:
 
    FrustumTest() noexcept
    {
        Frustum<T> frust;
        Matrix44<T> cameraMat;
        cameraMat.makeIdentity();
        setFrustum (frust, cameraMat);
    }
 
    FrustumTest (const Frustum<T>& frustum, const Matrix44<T>& cameraMat) noexcept
    {
        setFrustum (frustum, cameraMat);
    }
 
 
    
    void setFrustum (const Frustum<T>& frustum, const Matrix44<T>& cameraMat) noexcept;
 
 
    
    bool isVisible (const Sphere3<T>& sphere) const noexcept;
 
    bool isVisible (const Box<Vec3<T>>& box) const noexcept;
 
    bool isVisible (const Vec3<T>& vec) const noexcept;
 
    bool completelyContains (const Sphere3<T>& sphere) const noexcept;
 
    bool completelyContains (const Box<Vec3<T>>& box) const noexcept;
 
    ATOMSMATH_INTERNAL_NAMESPACE::Matrix44<T> cameraMat() const noexcept { return cameraMatrix; }
 
    ATOMSMATH_INTERNAL_NAMESPACE::Frustum<T> currentFrustum() const noexcept { return currFrustum; }
 
    
  protected:
 
    // To understand why the planes are stored this way, see
    // the SPECIAL NOTE above.
 
 
    Vec3<T> planeNormX[2]; // The X components from 6 plane equations
    Vec3<T> planeNormY[2]; // The Y components from 6 plane equations
    Vec3<T> planeNormZ[2]; // The Z components from 6 plane equations
 
    Vec3<T> planeOffsetVec[2]; // The distance offsets from 6 plane equations
 
    // The absolute values are stored to assist with bounding box tests.
    Vec3<T> planeNormAbsX[2]; // The abs(X) components from 6 plane equations
    Vec3<T> planeNormAbsY[2]; // The abs(X) components from 6 plane equations
    Vec3<T> planeNormAbsZ[2]; // The abs(X) components from 6 plane equations
 
    // These are kept primarily for debugging tools.
    Frustum<T> currFrustum;
    Matrix44<T> cameraMatrix;
 
};
 
template <class T>
void
FrustumTest<T>::setFrustum (const Frustum<T>& frustum, const Matrix44<T>& cameraMat) noexcept
{
    Plane3<T> frustumPlanes[6];
    frustum.planes (frustumPlanes, cameraMat);
 
    // Here's where we effectively transpose the plane equations.
    // We stuff all six X's into the two planeNormX vectors, etc.
    for (int i = 0; i < 2; ++i)
    {
        int index = i * 3;
 
        planeNormX[i] = Vec3<T> (frustumPlanes[index + 0].normal.x,
                                 frustumPlanes[index + 1].normal.x,
                                 frustumPlanes[index + 2].normal.x);
        planeNormY[i] = Vec3<T> (frustumPlanes[index + 0].normal.y,
                                 frustumPlanes[index + 1].normal.y,
                                 frustumPlanes[index + 2].normal.y);
        planeNormZ[i] = Vec3<T> (frustumPlanes[index + 0].normal.z,
                                 frustumPlanes[index + 1].normal.z,
                                 frustumPlanes[index + 2].normal.z);
 
        planeNormAbsX[i] = Vec3<T> (std::abs (planeNormX[i].x),
                                    std::abs (planeNormX[i].y),
                                    std::abs (planeNormX[i].z));
        planeNormAbsY[i] = Vec3<T> (std::abs (planeNormY[i].x),
                                    std::abs (planeNormY[i].y),
                                    std::abs (planeNormY[i].z));
        planeNormAbsZ[i] = Vec3<T> (std::abs (planeNormZ[i].x),
                                    std::abs (planeNormZ[i].y),
                                    std::abs (planeNormZ[i].z));
 
        planeOffsetVec[i] = Vec3<T> (frustumPlanes[index + 0].distance,
                                     frustumPlanes[index + 1].distance,
                                     frustumPlanes[index + 2].distance);
    }
    currFrustum  = frustum;
    cameraMatrix = cameraMat;
}
 
template <typename T>
bool
FrustumTest<T>::isVisible (const Sphere3<T>& sphere) const noexcept
{
    Vec3<T> center    = sphere.center;
    Vec3<T> radiusVec = Vec3<T> (sphere.radius, sphere.radius, sphere.radius);
 
    // This is a vertical dot-product on three vectors at once.
    Vec3<T> d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z -
                 radiusVec - planeOffsetVec[0];
 
    if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0)
        return false;
 
    Vec3<T> d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z -
                 radiusVec - planeOffsetVec[1];
 
    if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0)
        return false;
 
    return true;
}
 
template <typename T>
bool
FrustumTest<T>::completelyContains (const Sphere3<T>& sphere) const noexcept
{
    Vec3<T> center    = sphere.center;
    Vec3<T> radiusVec = Vec3<T> (sphere.radius, sphere.radius, sphere.radius);
 
    // This is a vertical dot-product on three vectors at once.
    Vec3<T> d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z +
                 radiusVec - planeOffsetVec[0];
 
    if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0)
        return false;
 
    Vec3<T> d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z +
                 radiusVec - planeOffsetVec[1];
 
    if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0)
        return false;
 
    return true;
}
 
template <typename T>
bool
FrustumTest<T>::isVisible (const Box<Vec3<T>>& box) const noexcept
{
    if (box.isEmpty())
        return false;
 
    Vec3<T> center = (box.min + box.max) / 2;
    Vec3<T> extent = (box.max - center);
 
    // This is a vertical dot-product on three vectors at once.
    Vec3<T> d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z -
                 planeNormAbsX[0] * extent.x - planeNormAbsY[0] * extent.y -
                 planeNormAbsZ[0] * extent.z - planeOffsetVec[0];
 
    if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0)
        return false;
 
    Vec3<T> d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z -
                 planeNormAbsX[1] * extent.x - planeNormAbsY[1] * extent.y -
                 planeNormAbsZ[1] * extent.z - planeOffsetVec[1];
 
    if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0)
        return false;
 
    return true;
}
 
template <typename T>
bool
FrustumTest<T>::completelyContains (const Box<Vec3<T>>& box) const noexcept
{
    if (box.isEmpty())
        return false;
 
    Vec3<T> center = (box.min + box.max) / 2;
    Vec3<T> extent = (box.max - center);
 
    // This is a vertical dot-product on three vectors at once.
    Vec3<T> d0 = planeNormX[0] * center.x + planeNormY[0] * center.y + planeNormZ[0] * center.z +
                 planeNormAbsX[0] * extent.x + planeNormAbsY[0] * extent.y +
                 planeNormAbsZ[0] * extent.z - planeOffsetVec[0];
 
    if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0)
        return false;
 
    Vec3<T> d1 = planeNormX[1] * center.x + planeNormY[1] * center.y + planeNormZ[1] * center.z +
                 planeNormAbsX[1] * extent.x + planeNormAbsY[1] * extent.y +
                 planeNormAbsZ[1] * extent.z - planeOffsetVec[1];
 
    if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0)
        return false;
 
    return true;
}
 
template <typename T>
bool
FrustumTest<T>::isVisible (const Vec3<T>& vec) const noexcept
{
    // This is a vertical dot-product on three vectors at once.
    Vec3<T> d0 = (planeNormX[0] * vec.x) + (planeNormY[0] * vec.y) + (planeNormZ[0] * vec.z) -
                 planeOffsetVec[0];
 
    if (d0.x >= 0 || d0.y >= 0 || d0.z >= 0)
        return false;
 
    Vec3<T> d1 = (planeNormX[1] * vec.x) + (planeNormY[1] * vec.y) + (planeNormZ[1] * vec.z) -
                 planeOffsetVec[1];
 
    if (d1.x >= 0 || d1.y >= 0 || d1.z >= 0)
        return false;
 
    return true;
}
 
typedef FrustumTest<float> FrustumTestf;
 
typedef FrustumTest<double> FrustumTestd;
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHFRUSTUMTEST_H