D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spConvexPolyhedron.hpp

Go to the documentation of this file.

/*
 * Convex polyhedron header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_CONVEXPOLYHEDRON_H__
#define __SP_CONVEXPOLYHEDRON_H__


#include "Base/spStandard.hpp"
#include "Base/spDimensionMatrix4.hpp"
#include "Base/spDimensionVector3D.hpp"
#include "Base/spDimensionPlane3D.hpp"
#include "Base/spDimensionAABB.hpp"


namespace sp
{
namespace scene
{


template <typename T, s32 PlaneCount> class ConvexPolyhedron
{
    
    public:
        
        ConvexPolyhedron()
        {
        }
        ConvexPolyhedron(const ConvexPolyhedron<T, PlaneCount> &Other)
        {
            for (s32 i = 0; i < PlaneCount; ++i)
                Planes_[i] = Other.Planes_[i];
        }
        virtual ~ConvexPolyhedron()
        {
        }
        
        /* === Functions === */
        
        bool isPointInside(const dim::vector3d<T> &Point, const T Radius = T(0)) const
        {
            for (s32 i = 0; i < PlaneCount; ++i)
            {
                if (Planes_[i].getPointDistance(Point) > Radius)
                    return false;
            }
            return true;
        }
        
        bool isBoundBoxInsideInv(const dim::aabbox3d<T> &Box, const dim::matrix4<T> &InvMatrix) const
        {
            for (s32 i = 0; i < PlaneCount; ++i)
            {
                if ((InvMatrix * Planes_[i]).getAABBoxRelation(Box) == dim::PLANE_RELATION_FRONT)
                    return false;
            }
            return true;
        }
        
        bool isBoundBoxInside(const dim::aabbox3d<T> &Box, const dim::matrix4<T> &Matrix) const
        {
            return isBoundBoxInsideInv(Box, Matrix.getInverse());
        }
        
        bool checkLineIntersection(const dim::line3d<T> &Line, dim::line3d<T> &Intersection) const
        {
            const dim::vector3d<T> Direction(Line.getDirection());
            
            T IntervalFirst = T(0);
            T IntervalLast  = T(1);
            
            /* Test line against each plane */
            for (s32 i = 0; i < PlaneCount; ++i)
            {
                T Denom = Planes_[i].Normal.dot(Direction);
                T Dist  = Planes_[i].Distance - Planes_[i].Normal.dot(Line.Start);
                
                /* Check if line runs parallel to the plane */
                if (Denom == T(0))
                {
                    if (Dist > T(0))
                        return false;
                }
                else
                {
                    T t = Dist / Denom;
                    
                    if (Denom < T(0))
                    {
                        if (t > IntervalFirst)
                            IntervalFirst = t;
                    }
                    else
                    {
                        if (t < IntervalLast)
                            IntervalLast = t;
                    }
                    
                    /* Exit with no intersection if intersection becomes empty */
                    if (IntervalFirst > IntervalLast)
                        return false;
                }
            }
            
            /* Return the intersection */
            Intersection.Start  = Line.Start + Direction * IntervalFirst;
            Intersection.End    = Line.Start + Direction * IntervalLast;
            
            return true;
        }
        
        void normalize()
        {
            for (s32 i = 0; i < PlaneCount; ++i)
                Planes_[i].normalize();
        }
        
        /* === Inline functions === */
        
        inline const dim::plane3d<T>& getPlane(u32 Index) const
        {
            return Planes_[Index];
        }
        inline dim::plane3d<T>& getPlane(u32 Index)
        {
            return Planes_[Index];
        }
        
        inline void setPlane(u32 Index, const dim::plane3d<T> &Plane)
        {
            if (Index < PlaneCount)
                Planes_[Index] = Plane;
        }
        
    protected:
        
        /* === Members === */
        
        dim::plane3d<T> Planes_[PlaneCount];
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================