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

Go to the documentation of this file.

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

#ifndef __SP_DIMENSION_LINE3D_H__
#define __SP_DIMENSION_LINE3D_H__


#include "Base/spStandard.hpp"
#include "Base/spDimensionVector3D.hpp"
#include "Base/spDimensionPoint2D.hpp"


namespace sp
{
namespace dim
{


enum ELinePointRelations
{
    LINE_RELATION_START,      
    LINE_RELATION_END,        
    LINE_RELATION_BETWEEN,    
};


template <typename T, template <typename> class Vec> class linekd
{
        
        typedef Vec<T> VecT;
        typedef linekd<T, Vec> L;
        
    public:
        
        linekd()
        {
        }
        linekd(const VecT &RayStart, const VecT &RayEnd) :
            Start   (RayStart   ),
            End     (RayEnd     )
        {
        }
        linekd(const L &Other) :
            Start   (Other.Start),
            End     (Other.End  )
        {
        }
        virtual ~linekd()
        {
        }
        
        /* === Operators === */
        
        inline bool operator == (const L &Other)
        {
            return Start == Other.Start && End == Other.End;
        }
        inline bool operator != (const L &Other)
        {
            return Start != Other.Start && End != Other.End;
        }
        
        inline L operator + (const L &Other) const
        {
            return L(Start + Other.Start, End + Other.End);
        }
        inline L& operator += (const L &Other)
        {
            Start += Other.Start; End += Other.End; return *this;
        }
        
        inline L operator - (const L &Other) const
        {
            return L(Start - Other.Start, End - Other.End);
        }
        inline L& operator -= (const L &Other)
        {
            Start -= Other.Start; End -= Other.End; return *this;
        }
        
        inline L operator / (const L &Other) const
        {
            return L(Start / Other.Start, End / Other.End);
        }
        inline L& operator /= (const L &Other)
        {
            Start /= Other.Start; End /= Other.End; return *this;
        }
        
        inline L operator * (const L &Other) const
        {
            return L(Start * Other.Start, End * Other.End);
        }
        inline L& operator *= (const L &Other)
        {
            Start *= Other.Start; End *= Other.End; return *this;
        }
        
        inline L operator - () const
        {
            return L(-Start, -End);
        }
        
        /* === Extra functions === */
        
        inline VecT getCenter() const
        {
            return (Start + End) / 2;
        }
        
        inline VecT getDirection() const
        {
            return End - Start;
        }
        
        inline L getViceVersa() const
        {
            return L(End, Start);
        }
        
        inline bool checkBoxBoxIntersection(const L &Line) const
        {
            return Start <= Line.End && End >= Line.Start;
        }
        
        inline bool isPointInside(const VecT &Point) const
        {
            return Point.isBetweenPoints(Start, End);
        }
        
        inline ELinePointRelations getClosestPointStraight(const VecT &Point, VecT &ClosestPoint) const
        {
            VecT Pos(Point - Start);
            VecT Dir(End - Start);
            
            T Len(Dir.getLength());
            Dir *= (T(1) / Len);
            T Factor(Dir.dot(Pos));
            
            Dir *= Factor;
            ClosestPoint = Start + Dir;
            
            if (Factor < T(0))
                return LINE_RELATION_START;
            if (Factor > Len)
                return LINE_RELATION_END;
            
            return LINE_RELATION_BETWEEN;
        }
        
        inline VecT getClosestPointStraight(const VecT &Point) const
        {
            VecT ClosestPoint;
            getClosestPointStraight(Point, ClosestPoint);
            return ClosestPoint;
        }
        
        inline ELinePointRelations getClosestPoint(const VecT &Point, VecT &ClosestPoint) const
        {
            VecT Pos(Point - Start);
            VecT Dir(End - Start);
            
            T Len(Dir.getLength());
            Dir *= (T(1) / Len);
            T Factor(Dir.dot(Pos));
            
            if (Factor < T(0))
            {
                ClosestPoint = Start;
                return LINE_RELATION_START;
            }
            if (Factor > Len)
            {
                ClosestPoint = End;
                return LINE_RELATION_END;
            }
            
            Dir *= Factor;
            
            ClosestPoint = Start + Dir;
            return LINE_RELATION_BETWEEN;
        }
        
        inline VecT getClosestPoint(const VecT &Point) const
        {
            VecT ClosestPoint;
            getClosestPoint(Point, ClosestPoint);
            return ClosestPoint;
        }
        
        inline T getPointDistance(const VecT &Point) const
        {
            return (getClosestPoint(Point) - Point).getLength();
        }
        
        inline T getPointDistanceSq(const VecT &Point) const
        {
            return (getClosestPoint(Point) - Point).getLengthSq();
        }
        
        /* Members */
        
        VecT Start, End;
        
};

template <typename T> class line3d : public linekd<T, vector3d>
{
    
    public:
        
        line3d() :
            linekd<T, vector3d>()
        {
        }
        line3d(const vector3d<T> &Start, const vector3d<T> &End) :
            linekd<T, vector3d>(Start, End)
        {
        }
        line3d(const linekd<T, vector3d> &Other) :
            linekd<T, vector3d>(Other)
        {
        }
        ~line3d()
        {
        }
        
};

template <typename T> class line2d : public linekd<T, point2d>
{
    
    public:
        
        line2d() :
            linekd<T, point2d>()
        {
        }
        line2d(const point2d<T> &Start, const point2d<T> &End) :
            linekd<T, point2d>(Start, End)
        {
        }
        line2d(const linekd<T, point2d> &Other) :
            linekd<T, point2d>(Other)
        {
        }
        ~line2d()
        {
        }
        
};

typedef linekd<s32, vector3d> line3di;
typedef linekd<f32, vector3d> line3df;

typedef linekd<s32, point2d> line2di;
typedef linekd<f32, point2d> line2df;


} // /namespace dim

} // /namespace sp


#endif



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