frustum.cpp

Go to the documentation of this file.

/* MAINTAINER: Martin */

#include "frustum.h"


Frustum::Frustum(const Frustum & f):mPlanes(6)
{
        for (int i = 0; i < 6; ++i)
                mPlanes[i] = f.mPlanes[i];
}

void Frustum::normalizePlane(TPlaneID planeID)
{
        assertL(planeID >= 0 && planeID < (int)mPlanes.size() && "Bad frustum plane ID!");
        const GLVector3d &n = mPlanes[planeID].getNormal();
        double len = n.length();
        if (len) 
                len = 1/len;
        mPlanes[planeID].setNormal(n * len);
        mPlanes[planeID].setD(mPlanes[planeID].getD() * len);
}

void Frustum::normalizeAllPlanes(void)
{
        normalizePlane(PL_LEFT);
        normalizePlane(PL_TOP);
        normalizePlane(PL_RIGHT);
        normalizePlane(PL_BOTTOM);
        normalizePlane(PL_FAR);
        normalizePlane(PL_NEAR);
}

void Frustum::set(const GLMatrix4d &m, bool normalize)
{
        // Left clipping plane
        mPlanes[PL_LEFT].setNormal(
                GLVector3d(
                        m[mi(4, 1)] + m[mi(1, 1)],
                        m[mi(4, 2)] + m[mi(1, 2)],
                        m[mi(4, 3)] + m[mi(1, 3)]
                ));
        mPlanes[PL_LEFT].setD(m[mi(4, 4)] + m[mi(1, 4)]);
        
        // Right clipping plane
        mPlanes[PL_RIGHT].setNormal(
                GLVector3d(
                        m[mi(4, 1)] - m[mi(1, 1)],
                        m[mi(4, 2)] - m[mi(1, 2)],
                        m[mi(4, 3)] - m[mi(1, 3)]
                ));
        mPlanes[PL_RIGHT].setD(m[mi(4, 4)] - m[mi(1, 4)]);
        
        // Top clipping plane
        mPlanes[PL_TOP].setNormal(
                GLVector3d(
                        m[mi(4, 1)] - m[mi(2, 1)],
                        m[mi(4, 2)] - m[mi(2, 2)],
                        m[mi(4, 3)] - m[mi(2, 3)]
                ));
        mPlanes[PL_TOP].setD(m[mi(4, 4)] - m[mi(2, 4)]);
        
        // Bottom clipping plane
        mPlanes[PL_BOTTOM].setNormal(
                GLVector3d(
                        m[mi(4, 1)] + m[mi(2, 1)],
                        m[mi(4, 2)] + m[mi(2, 2)],
                        m[mi(4, 3)] + m[mi(2, 3)]
                ));
        mPlanes[PL_BOTTOM].setD(m[mi(4, 4)] + m[mi(2, 4)]);
        
        // Near clipping plane
        mPlanes[PL_NEAR].setNormal(
                GLVector3d(
                        m[mi(4, 1)] + m[mi(3, 1)],
                        m[mi(4, 2)] + m[mi(3, 2)],
                        m[mi(4, 3)] + m[mi(3, 3)]
                ));
        mPlanes[PL_NEAR].setD(m[mi(4, 4)] + m[mi(3, 4)]);
        
        // Far clipping plane
        mPlanes[PL_FAR].setNormal(
                GLVector3d(
                        m[mi(4, 1)] - m[mi(3, 1)],
                        m[mi(4, 2)] - m[mi(3, 2)],
                        m[mi(4, 3)] - m[mi(3, 3)]
                ));
        mPlanes[PL_FAR].setD(m[mi(4, 4)] - m[mi(3, 4)]);

        if (normalize)
                normalizeAllPlanes();
}

void Frustum::transform(const GLMatrix4d &m, bool normalize)
{
        GLMatrix4d mt(m);
        mt.transpose();

        for (TPlaneContainer::iterator it = mPlanes.begin(), ite = mPlanes.end(); it != ite; ++it){
                const GLVector3d &n = it->getNormal();
                GLVector4d v(n.x, n.y, n.z, it->getD()), q;
                q = mt * v;
                it->setNormal(GLVector3d(q.x, q.y, q.z));
                it->setD(q.w);
        }
        if (normalize)
                normalizeAllPlanes();
}

Frustum::Halfspace Frustum::classifyPoint(const TPlane &plane, const GLVector3d &point, const double eps)
{
        const double f(plane.getNormal().dot(point) + plane.getD());

        if (f < eps)
                return NEGATIVE;
        else if (f > eps)
                return POSITIVE;
        
        return ON_PLANE;
}

bool Frustum::testPoint(const GLVector3d &p)
{
        Halfspace h[6];
        h[0] = classifyPoint(getPlane(PL_LEFT), p);
        h[1] = classifyPoint(getPlane(PL_TOP), p);
        h[2] = classifyPoint(getPlane(PL_RIGHT), p);
        h[3] = classifyPoint(getPlane(PL_BOTTOM), p);
        h[4] = classifyPoint(getPlane(PL_FAR), p);
        h[5] = classifyPoint(getPlane(PL_NEAR), p);
        
        bool inside = true;
        for (int i = 0; i < 6; ++i)
                inside &= (h[i] >= 0);

        return inside;
}

Frustum::ClipState Frustum::testSphere(const GLVector3d &center, const double radius) const
{
        double dist;
        int intersect(0);

        // for each plane ...
        for (TPlaneContainer::const_iterator it = mPlanes.begin(), ite = mPlanes.end(); it != ite; ++it) {
                // the distance of center and the plane 
                dist = it->distanceToPoint(center);
                if (dist < -radius)
                        return Frustum::OUTSIDE;
                if (fabs(dist) < radius)
                        ++intersect;
        }
        if (!intersect)
                return Frustum::INSIDE;
        return Frustum::INTERSECT;
}

Frustum::ClipState Frustum::testBox(const GLVector3d &center, const GLVector3d &extent) const
{
        const double eps = 0.0;
        
        GLVector3d v[8];
        
        v[0] = center + GLVector3d(extent.x, extent.y, extent.z);
        v[1] = center + GLVector3d(extent.x, extent.y, -extent.z);
        v[2] = center + GLVector3d(extent.x, -extent.y, extent.z);
        v[3] = center + GLVector3d(extent.x, -extent.y, -extent.z);
        v[4] = center + GLVector3d(-extent.x, extent.y, extent.z);
        v[5] = center + GLVector3d(-extent.x, extent.y, -extent.z);
        v[6] = center + GLVector3d(-extent.x, -extent.y, extent.z);
        v[7] = center + GLVector3d(-extent.x, -extent.y, -extent.z);

        // for each plane ...
        bool all_inside = true;
        for (TPlaneContainer::const_iterator it = mPlanes.begin(), ite = mPlanes.end(); it != ite; ++it) {
                int outside_count = 0;

                // test all points
                for (int i = 0; i < 8; ++i) {
                        Halfspace hs = classifyPoint(*it, v[i], eps);
                        if (hs == NEGATIVE) {
                                ++outside_count;
                                all_inside = false;
                        }
                }

                if (outside_count == 8)
                        return OUTSIDE;
        }

        if (all_inside)
                return Frustum::INSIDE;

        return Frustum::INTERSECT;
}

---