vector3.hpp

#ifndef BLUB_MATH_VECTOR3_HPP
#define BLUB_MATH_VECTOR3_HPP

#include "blub/core/classVersion.hpp"
#include "blub/core/globals.hpp"
#include "blub/math/math.hpp"
#include "blub/math/predecl.hpp"
#include "blub/serialization/access.hpp"
#include "blub/serialization/nameValuePair.hpp"
#ifdef BLUB_USE_PHYSX
#   include <foundation/PxVec3.h>
#endif

#ifdef BLUB_USE_BULLET
class btVector3;
#endif
namespace Ogre
{
    class Vector3;
}


namespace blub
{

class vector3
{
public:
    vector3()
        : x(0.)
        , y(0.)
        , z(0.)
    {
    }

#ifndef BLUB_NO_OGRE3D
    vector3(const Ogre::Vector3 &vec);
    operator Ogre::Vector3() const;
#endif
#ifdef BLUB_USE_PHYSX
    vector3(const physx::PxVec3& other)
        : x(other.x), y(other.y), z(other.z)
    {}
    operator physx::PxVec3() const
    {return physx::PxVec3(x,y,z);}
#endif
#ifdef BLUB_USE_BULLET
    vector3(const btVector3 &vec);
    operator btVector3() const;
#endif

    vector3(const real fX, const real fY, const real fZ)
        : x(fX)
        , y(fY)
        , z(fZ)
    {
    }

    vector3(const real& scaler)
        : x(scaler)
        , y(scaler)
        , z(scaler)
    {
    }

    vector3(const vector3int32& cast);

    bool operator <= ( const vector3& rhs ) const
    {
        return x <= rhs.x && y <= rhs.y && z <= rhs.z;
    }

    bool operator >= ( const vector3& rhs ) const
    {
        return x >= rhs.x && y >= rhs.y && z >= rhs.z;
    }

    vector3 getFloor(void) const;
    vector3 getAbs(void) const;


    inline void swap(vector3& other)
    {
        std::swap(x, other.x);
        std::swap(y, other.y);
        std::swap(z, other.z);
    }

    inline real operator [] ( const size_t i ) const
    {
        BASSERT( i < 3 );

        return *(&x+i);
    }

    inline real& operator [] ( const size_t i )
    {
        BASSERT( i < 3 );

        return *(&x+i);
    }
    inline real* ptr()
    {
        return &x;
    }
    inline const real* ptr() const
    {
        return &x;
    }

    inline vector3& operator = ( const real fScaler )
    {
        x = fScaler;
        y = fScaler;
        z = fScaler;

        return *this;
    }

    inline bool operator == ( const vector3& rkVector ) const
    {
        return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
    }

    inline bool operator != ( const vector3& rkVector ) const
    {
        return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
    }

    // arithmetic operations
    inline vector3 operator + ( const vector3& rkVector ) const
    {
        return vector3(
            x + rkVector.x,
            y + rkVector.y,
            z + rkVector.z);
    }

    inline vector3 operator - ( const vector3& rkVector ) const
    {
        return vector3(
            x - rkVector.x,
            y - rkVector.y,
            z - rkVector.z);
    }

    inline vector3 operator * ( const real fScalar ) const
    {
        return vector3(
            x * fScalar,
            y * fScalar,
            z * fScalar);
    }

    inline vector3 operator * ( const vector3& rhs) const
    {
        return vector3(
            x * rhs.x,
            y * rhs.y,
            z * rhs.z);
    }

    inline vector3 operator / ( const real fScalar ) const
    {
        BASSERT( fScalar != 0.0 );

        real fInv = 1.0f / fScalar;

        return vector3(
            x * fInv,
            y * fInv,
            z * fInv);
    }

    inline vector3 operator / ( const vector3& rhs) const
    {
        return vector3(
            x / rhs.x,
            y / rhs.y,
            z / rhs.z);
    }

    inline const vector3& operator + () const
    {
        return *this;
    }

    inline vector3 operator - () const
    {
        return vector3(-x, -y, -z);
    }

    // overloaded operators to help vector3
    inline friend vector3 operator * ( const real fScalar, const vector3& rkVector )
    {
        return vector3(
            fScalar * rkVector.x,
            fScalar * rkVector.y,
            fScalar * rkVector.z);
    }

    inline friend vector3 operator / ( const real fScalar, const vector3& rkVector )
    {
        return vector3(
            fScalar / rkVector.x,
            fScalar / rkVector.y,
            fScalar / rkVector.z);
    }

    inline friend vector3 operator + (const vector3& lhs, const real rhs)
    {
        return vector3(
            lhs.x + rhs,
            lhs.y + rhs,
            lhs.z + rhs);
    }

    inline friend vector3 operator + (const real lhs, const vector3& rhs)
    {
        return vector3(
            lhs + rhs.x,
            lhs + rhs.y,
            lhs + rhs.z);
    }

    inline friend vector3 operator - (const vector3& lhs, const real rhs)
    {
        return vector3(
            lhs.x - rhs,
            lhs.y - rhs,
            lhs.z - rhs);
    }

    inline friend vector3 operator - (const real lhs, const vector3& rhs)
    {
        return vector3(
            lhs - rhs.x,
            lhs - rhs.y,
            lhs - rhs.z);
    }

    // arithmetic updates
    inline vector3& operator += ( const vector3& rkVector )
    {
        x += rkVector.x;
        y += rkVector.y;
        z += rkVector.z;

        return *this;
    }

    inline vector3& operator += ( const real fScalar )
    {
        x += fScalar;
        y += fScalar;
        z += fScalar;
        return *this;
    }

    inline vector3& operator -= ( const vector3& rkVector )
    {
        x -= rkVector.x;
        y -= rkVector.y;
        z -= rkVector.z;

        return *this;
    }

    inline vector3& operator -= ( const real fScalar )
    {
        x -= fScalar;
        y -= fScalar;
        z -= fScalar;
        return *this;
    }

    inline vector3& operator *= ( const real fScalar )
    {
        x *= fScalar;
        y *= fScalar;
        z *= fScalar;
        return *this;
    }

    inline vector3& operator *= ( const vector3& rkVector )
    {
        x *= rkVector.x;
        y *= rkVector.y;
        z *= rkVector.z;

        return *this;
    }

    inline vector3& operator /= ( const real fScalar )
    {
        BASSERT( fScalar != 0.0 );

        real fInv = 1.0f / fScalar;

        x *= fInv;
        y *= fInv;
        z *= fInv;

        return *this;
    }

    inline vector3& operator /= ( const vector3& rkVector )
    {
        x /= rkVector.x;
        y /= rkVector.y;
        z /= rkVector.z;

        return *this;
    }


    inline real length () const
    {
        return math::sqrt( x * x + y * y + z * z );
    }

    inline real squaredLength () const
    {
        return x * x + y * y + z * z;
    }

    inline real distance(const vector3& rhs) const
    {
        return (*this - rhs).length();
    }

    inline real squaredDistance(const vector3& rhs) const
    {
        return (*this - rhs).squaredLength();
    }

    inline real dotProduct(const vector3& vec) const
    {
        return x * vec.x + y * vec.y + z * vec.z;
    }

    inline real absDotProduct(const vector3& vec) const
    {
        return math::abs(x * vec.x) + math::abs(y * vec.y) + math::abs(z * vec.z);
    }

    inline real normalise()
    {
        real fLength = math::sqrt( x * x + y * y + z * z );

        // Will also work for zero-sized vectors, but will change nothing
        // We're not using epsilons because we don't need to.
        // Read http://www.ogre3d.org/forums/viewtopic.php?f=4&t=61259
        if ( fLength > real(0.0f) )
        {
            real fInvLength = 1.0f / fLength;
            x *= fInvLength;
            y *= fInvLength;
            z *= fInvLength;
        }

        return fLength;
    }

    inline vector3 crossProduct( const vector3& rkVector ) const
    {
        return vector3(
            y * rkVector.z - z * rkVector.y,
            z * rkVector.x - x * rkVector.z,
            x * rkVector.y - y * rkVector.x);
    }

    inline vector3 midPoint( const vector3& vec ) const
    {
        return vector3(
            ( x + vec.x ) * 0.5f,
            ( y + vec.y ) * 0.5f,
            ( z + vec.z ) * 0.5f );
    }

    inline bool operator < ( const vector3& rhs ) const
    {
        if( x < rhs.x && y < rhs.y && z < rhs.z )
            return true;
        return false;
    }

    inline bool operator > ( const vector3& rhs ) const
    {
        if( x > rhs.x && y > rhs.y && z > rhs.z )
            return true;
        return false;
    }

    inline void makeFloor( const vector3& cmp )
    {
        if( cmp.x < x ) x = cmp.x;
        if( cmp.y < y ) y = cmp.y;
        if( cmp.z < z ) z = cmp.z;
    }

    inline void makeCeil( const vector3& cmp )
    {
        if( cmp.x > x ) x = cmp.x;
        if( cmp.y > y ) y = cmp.y;
        if( cmp.z > z ) z = cmp.z;
    }

    inline vector3 perpendicular(void) const
    {
        static const real fSquareZero = (real)(1e-06 * 1e-06);

        vector3 perp = this->crossProduct( vector3::UNIT_X );

        // Check length
        if( perp.squaredLength() < fSquareZero )
        {
            /* This vector is the Y axis multiplied by a scalar, so we have
               to use another axis.
            */
            perp = this->crossProduct( vector3::UNIT_Y );
        }
        perp.normalise();

        return perp;
    }


    inline real angleBetween(const vector3& dest) const
    {
        real lenProduct = length() * dest.length();

        // Divide by zero check
        if(lenProduct < 1e-6f)
            lenProduct = 1e-6f;

        real f = dotProduct(dest) / lenProduct;

        f = math::clamp(f, (real)-1.0, (real)1.0);
        return math::acos(f);

    }
    quaternion getRotationTo(const vector3& dest,
        const vector3& fallbackAxis = vector3::ZERO) const;

    inline bool isZeroLength(void) const
    {
        real sqlen = (x * x) + (y * y) + (z * z);
        return (sqlen < (1e-06 * 1e-06));

    }

    inline vector3 getNormalise() const
    {
        return normalisedCopy();
    }

    inline vector3 normalisedCopy(void) const
    {
        vector3 ret = *this;
        ret.normalise();
        return ret;
    }

    inline vector3 reflect(const vector3& normal) const
    {
        return vector3( *this - ( 2 * this->dotProduct(normal) * normal ) );
    }

    inline bool positionCloses(const vector3& rhs, real tolerance = 1e-03f) const
    {
        return squaredDistance(rhs) <=
            (squaredLength() + rhs.squaredLength()) * tolerance;
    }

    inline vector3 primaryAxis() const
    {
        real absx = math::abs(x);
        real absy = math::abs(y);
        real absz = math::abs(z);
        if (absx > absy)
            if (absx > absz)
                return x > 0 ? vector3::UNIT_X : vector3::NEGATIVE_UNIT_X;
            else
                return z > 0 ? vector3::UNIT_Z : vector3::NEGATIVE_UNIT_Z;
        else // absx <= absy
            if (absy > absz)
                return y > 0 ? vector3::UNIT_Y : vector3::NEGATIVE_UNIT_Y;
            else
                return z > 0 ? vector3::UNIT_Z : vector3::NEGATIVE_UNIT_Z;


    }

public:
    real x, y, z;

    static const vector3 ZERO;
    static const vector3 UNIT_X;
    static const vector3 UNIT_Y;
    static const vector3 UNIT_Z;
    static const vector3 NEGATIVE_UNIT_X;
    static const vector3 NEGATIVE_UNIT_Y;
    static const vector3 NEGATIVE_UNIT_Z;
    static const vector3 UNIT_SCALE;

private:
    BLUB_SERIALIZATION_ACCESS

    template <class formatType>
    void serialize(formatType & readWrite, const uint32& version)
    {
        (void)version;

        readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(x);
        readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(y);
        readWrite & BLUB_SERIALIZATION_NAMEVALUEPAIR(z);
    }
};


std::ostream& operator<< (std::ostream& ostr, const vector3& toCast);
std::size_t hash_value(const vector3& value);


}
BLUB_CLASSVERSION(blub::vector3, 1)


#endif // BLUB_MATH_VECTOR3_HPP