ParaDVector3.h

#pragma once
#include "ParaMath.h"
#include "ParaQuaternion.h"
#include "ParaVector3.h"

namespace ParaEngine
{
    class Matrix4;

    class DVector3
    {
    public:
        double x, y, z;

    public:
        inline DVector3()
        {
        }

        inline DVector3(const double fX, const double fY, const double fZ)
            : x( fX ), y( fY ), z( fZ )
        {
        }

        inline explicit DVector3(const double afCoordinate[3])
            : x( afCoordinate[0] ), y( afCoordinate[1] ), z( afCoordinate[2] )
        {
        }

        inline explicit DVector3( const int afCoordinate[3] )
        {
            x = (double)afCoordinate[0];
            y = (double)afCoordinate[1];
            z = (double)afCoordinate[2];
        }

        inline explicit DVector3( double* const r )
            : x( r[0] ), y( r[1] ), z( r[2] )
        {
        }

        inline explicit DVector3( const double scaler )
            : x( scaler ), y( scaler ) , z( scaler )
        {
        }

        inline explicit DVector3(const Vector3& vFrom)
            : x(vFrom.x), y(vFrom.y), z(vFrom.z)
        {
        }

        inline double operator [] ( const size_t i ) const
        {
            assert( i < 3 );

            return *(&x+i);
        }

        inline double& operator [] ( const size_t i )
        {
            assert( i < 3 );

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

        operator Vector3 () const {
            return Vector3((float)x, (float)y, (float)z);
        };

        /*inline operator double* () { return &x; };
        inline operator const double* () const { return &x; };*/

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

            return *this;
        }

        inline DVector3& operator = (const Vector3& rkVector)
        {
            x = rkVector.x;
            y = rkVector.y;
            z = rkVector.z;
            return *this;
        }

        inline DVector3& operator = ( const double fScaler )
        {
            x = fScaler;
            y = fScaler;
            z = fScaler;

            return *this;
        }

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

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

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

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

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

        inline DVector3 operator * ( const double fScalar ) const
        {
            return DVector3(
                x * fScalar,
                y * fScalar,
                z * fScalar);
        }

        inline DVector3 operator % (const DVector3& rhs) const
        {
            return crossProduct(rhs);
        }

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

        inline DVector3 operator / ( const double fScalar ) const
        {
            assert( fScalar != 0.0f );

            double fInv = 1.0f / fScalar;

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

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

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

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

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

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

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

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

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

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

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

            return *this;
        }

        inline DVector3& operator += (const Vector3& rkVector)
        {
            x += rkVector.x;
            y += rkVector.y;
            z += rkVector.z;
            return *this;
        }

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

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

            return *this;
        }

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

            return *this;
        }

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

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

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

            return *this;
        }

        inline DVector3& operator /= ( const double fScalar )
        {
            assert( fScalar != 0.0f );

            double fInv = 1.0f / fScalar;

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

            return *this;
        }

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

            return *this;
        }


        inline double length () const
        {
            return Math::Sqrt( x * x + y * y + z * z );
        }

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

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

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

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

        inline double absDotProduct(const DVector3& vec) const
        {
            return Math::Abs(x * vec.x) + Math::Abs(y * vec.y) + Math::Abs(z * vec.z);
        }

        inline double normalise()
        {
            double fLength = Math::Sqrt( x * x + y * y + z * z );

            // Will also work for zero-sized vectors, but will change nothing
            if ( fLength > 1e-08 )
            {
                double fInvLength = 1.0f / fLength;
                x *= fInvLength;
                y *= fInvLength;
                z *= fInvLength;
            }

            return fLength;
        }

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

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

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

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

        inline void makeFloor( const DVector3& 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 DVector3& cmp )
        {
            if( cmp.x > x ) x = cmp.x;
            if( cmp.y > y ) y = cmp.y;
            if( cmp.z > z ) z = cmp.z;
        }

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

        }

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

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

        inline bool positionEquals(const Vector3& rhs, float tolerance = 1e-03) const
        {
            return Math::RealEqual((float)x, rhs.x, tolerance) &&
                Math::RealEqual((float)y, rhs.y, tolerance) &&
                Math::RealEqual((float)z, rhs.z, tolerance);
        }

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

        inline bool directionEquals(const DVector3& rhs,
            const Radian& tolerance) const
        {
            double dot = dotProduct(rhs);
            Radian angle = Math::ACos((float)dot);

            return Math::Abs(angle.valueRadians()) <= tolerance.valueRadians();
        }

        inline friend std::ostream& operator <<
            ( std::ostream& o, const DVector3& v )
        {
            o << "DVector3(" << v.x << ", " << v.y << ", " << v.z << ")";
            return o;
        }
    };

}