plane3d.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_PLANE_3D_HPP_INCLUDED
#define NIRT_PLANE_3D_HPP_INCLUDED
 
#include <nirtcpp/core/engine/irrMath.hpp>
#include <nirtcpp/core/engine/vector3d.hpp>
 
namespace nirt
{
namespace core
{
 
enum EIntersectionRelation3D
{
    ISREL3D_FRONT = 0,
    ISREL3D_BACK,
    ISREL3D_PLANAR,
    ISREL3D_SPANNING,
    ISREL3D_CLIPPED
};
 
 
template <class T>
class plane3d
{
    public:
 
        // Constructors
 
        plane3d(): Normal(0,1,0) { recalculateD(vector3d<T>(0,0,0)); }
 
        plane3d(const vector3d<T>& MPoint, const vector3d<T>& Normal) : Normal(Normal) { recalculateD(MPoint); }
 
        plane3d(T px, T py, T pz, T nx, T ny, T nz) : Normal(nx, ny, nz) { recalculateD(vector3d<T>(px, py, pz)); }
 
        plane3d(const vector3d<T>& point1, const vector3d<T>& point2, const vector3d<T>& point3)
        { setPlane(point1, point2, point3); }
 
        plane3d(const vector3d<T> & normal, const T d) : Normal(normal), D(d) { }
 
        // operators
 
        inline bool operator==(const plane3d<T>& other) const { return (equals(D, other.D) && Normal==other.Normal);}
 
        inline bool operator!=(const plane3d<T>& other) const { return !(*this == other);}
 
        // functions
 
        void setPlane(const vector3d<T>& point, const vector3d<T>& nvector)
        {
            Normal = nvector;
            recalculateD(point);
        }
 
        void setPlane(const vector3d<T>& nvect, T d)
        {
            Normal = nvect;
            D = d;
        }
 
        void setPlane(const vector3d<T>& point1, const vector3d<T>& point2, const vector3d<T>& point3)
        {
            // creates the plane from 3 memberpoints
            Normal = (point2 - point1).crossProduct(point3 - point1);
            Normal.normalize();
 
            recalculateD(point1);
        }
 
 
 
        bool getIntersectionWithLine(const vector3d<T>& linePoint,
                const vector3d<T>& lineVect,
                vector3d<T>& outIntersection) const
        {
            T t2 = Normal.dotProduct(lineVect);
 
            if (t2 == 0)
                return false;
 
            T t =- (Normal.dotProduct(linePoint) + D) / t2;
            outIntersection = linePoint + (lineVect * t);
            return true;
        }
 
 
        f32 getKnownIntersectionWithLine(const vector3d<T>& linePoint1,
            const vector3d<T>& linePoint2) const
        {
            vector3d<T> vect = linePoint2 - linePoint1;
            T t2 = (f32)Normal.dotProduct(vect);
            return (f32)-((Normal.dotProduct(linePoint1) + D) / t2);
        }
 
 
        bool getIntersectionWithLimitedLine(
                const vector3d<T>& linePoint1,
                const vector3d<T>& linePoint2,
                vector3d<T>& outIntersection) const
        {
            return (getIntersectionWithLine(linePoint1, linePoint2 - linePoint1, outIntersection) &&
                    outIntersection.isBetweenPoints(linePoint1, linePoint2));
        }
 
 
        EIntersectionRelation3D classifyPointRelation(const vector3d<T>& point) const
        {
            const T d = Normal.dotProduct(point) + D;
 
            if (d < -ROUNDING_ERROR_f32)
                return ISREL3D_BACK;
 
            if (d > ROUNDING_ERROR_f32)
                return ISREL3D_FRONT;
 
            return ISREL3D_PLANAR;
        }
 
        void recalculateD(const vector3d<T>& MPoint)
        {
            D = - MPoint.dotProduct(Normal);
        }
 
        vector3d<T> getMemberPoint() const
        {
            return Normal * -D;
        }
 
 
        bool existsIntersection(const plane3d<T>& other) const
        {
            vector3d<T> cross = other.Normal.crossProduct(Normal);
            return cross.getLength() > core::ROUNDING_ERROR_f32;
        }
 
 
        bool getIntersectionWithPlane(const plane3d<T>& other,
                vector3d<T>& outLinePoint,
                vector3d<T>& outLineVect) const
        {
            const T fn00 = Normal.getLength();
            const T fn01 = Normal.dotProduct(other.Normal);
            const T fn11 = other.Normal.getLength();
            const f64 det = fn00*fn11 - fn01*fn01;
 
            if (fabs(det) < ROUNDING_ERROR_f64 )
                return false;
 
            const f64 invdet = 1.0 / det;
            const f64 fc0 = (fn11*-D + fn01*other.D) * invdet;
            const f64 fc1 = (fn00*-other.D + fn01*D) * invdet;
 
            outLineVect = Normal.crossProduct(other.Normal);
            outLinePoint = Normal*(T)fc0 + other.Normal*(T)fc1;
            return true;
        }
 
        bool getIntersectionWithPlanes(const plane3d<T>& o1,
                const plane3d<T>& o2, vector3d<T>& outPoint) const
        {
            vector3d<T> linePoint, lineVect;
            if (getIntersectionWithPlane(o1, linePoint, lineVect))
                return o2.getIntersectionWithLine(linePoint, lineVect, outPoint);
 
            return false;
        }
 
 
        bool isFrontFacing(const vector3d<T>& lookDirection) const
        {
            const f32 d = Normal.dotProduct(lookDirection);
            return F32_LOWER_EQUAL_0 ( d );
        }
 
 
        T getDistanceTo(const vector3d<T>& point) const
        {
            return point.dotProduct(Normal) + D;
        }
 
        vector3d<T> Normal;
 
        T D;
};
 
 
using plane3df = plane3d<f32>;
 
using plane3di = plane3d<s32>;
 
} // end namespace core
} // end namespace nirt
 
#endif