glc_vector4d.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GLC-lib is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_VECTOR4D_H_
#define GLC_VECTOR4D_H_

#include <QVector>
#include <QDataStream>

#include "glc_utils_maths.h"
#include "glc_vector2d.h"
#include "glc_vector3d.h"
#include "glc_vector3df.h"

#include "../glc_config.h"




class GLC_LIB_EXPORT GLC_Vector4d
{
        friend class GLC_Matrix4x4;

        inline friend GLC_Vector4d operator - (const GLC_Vector4d &Vect)
        {
                return GLC_Vector4d(-Vect.vector[0], -Vect.vector[1], -Vect.vector[2]);
        }




public:
        inline GLC_Vector4d()
        {
                vector[0]= 0.0;
                vector[1]= 0.0;
                vector[2]= 0.0;

                vector[3]= 1.0;
        }
        inline GLC_Vector4d(const double &dX, const double &dY, const double &dZ, const double &dW= 1.0)
        {
                setVect(dX, dY, dZ, dW);
        }
        inline GLC_Vector4d(const GLC_Vector4d &Vect)
        {
                vector[0]= Vect.vector[0];
                vector[1]= Vect.vector[1];
                vector[2]= Vect.vector[2];
                vector[3]= Vect.vector[3];
        }

        inline GLC_Vector4d(const GLC_Vector3d &Vect)
        {
                vector[0]= Vect.m_Vector[0];
                vector[1]= Vect.m_Vector[1];
                vector[2]= Vect.m_Vector[2];
                vector[3]= 1.0;
        }

        inline GLC_Vector4d(const GLC_Vector3df &Vect)
        {
                vector[0]= static_cast<double>(Vect.m_Vector[0]);
                vector[1]= static_cast<double>(Vect.m_Vector[1]);
                vector[2]= static_cast<double>(Vect.m_Vector[2]);
                vector[3]= 1.0;
        }

        inline GLC_Vector4d(const GLC_Vector2d &Vect)
        {
                vector[0]= Vect.dVecteur[0];
                vector[1]= Vect.dVecteur[1];
                vector[2]= 0.0;
                vector[3]= 1.0;
        }




public:
        inline GLC_Vector4d operator + (const GLC_Vector4d &Vect) const
        {
                GLC_Vector4d VectResult(vector[0] + Vect.vector[0], vector[1] + Vect.vector[1],
                        vector[2] + Vect.vector[2]);

                return VectResult;
        }

        inline GLC_Vector4d& operator = (const GLC_Vector4d &Vect)
        {
                vector[0]= Vect.vector[0];
                vector[1]= Vect.vector[1];
                vector[2]= Vect.vector[2];
                vector[3]= Vect.vector[3];

                return *this;
        }

        inline GLC_Vector4d& operator = (const GLC_Vector3d &Vect)
        {
                vector[0]= Vect.m_Vector[0];
                vector[1]= Vect.m_Vector[1];
                vector[2]= Vect.m_Vector[2];
                vector[3]= 1.0;

                return *this;
        }

        inline GLC_Vector4d& operator = (const GLC_Vector3df &Vect)
        {
                vector[0]= static_cast<double>(Vect.m_Vector[0]);
                vector[1]= static_cast<double>(Vect.m_Vector[1]);
                vector[2]= static_cast<double>(Vect.m_Vector[2]);
                vector[3]= 1.0;

                return *this;
        }

        inline GLC_Vector4d& operator = (const GLC_Vector2d &Vect)
        {
                vector[0]= Vect.dVecteur[0];
                vector[1]= Vect.dVecteur[1];
                vector[2]= 0.0;
                vector[3]= 1.0;

                return *this;
        }

        inline GLC_Vector4d* operator += (const GLC_Vector4d &Vect)
        {
                *this= *this + Vect;
                return this;
        }


        inline GLC_Vector4d operator - (const GLC_Vector4d &Vect) const
        {
                GLC_Vector4d VectResult(vector[0] - Vect.vector[0], vector[1] - Vect.vector[1],
                        vector[2] - Vect.vector[2]);

                return VectResult;
        }

        GLC_Vector4d* operator -= (const GLC_Vector4d &Vect)
        {
                *this= *this - Vect;
                return this;
        }

        GLC_Vector4d operator ^ (const GLC_Vector4d &Vect) const;

        inline double operator * (const GLC_Vector4d &Vect) const
        {
                // W Component is ignored
                return vector[0] * Vect.vector[0] + vector[1] * Vect.vector[1] +
                        vector[2] * Vect.vector[2];
        }

        inline GLC_Vector4d operator * (double Scalaire) const
        {
                return GLC_Vector4d(vector[0] * Scalaire, vector[1] * Scalaire, vector[2] * Scalaire);
        }


        bool operator == (const GLC_Vector4d &Vect) const;

        inline bool operator != (const GLC_Vector4d &Vect) const
        {
                return !(*this == Vect);
        }




public:
        inline GLC_Vector4d& setX(const double &dX)
        {
                vector[0]= dX;
                return *this;
        }

        inline GLC_Vector4d& setY(const double &dY)
        {
                vector[1]= dY;
                return *this;
        }

        inline GLC_Vector4d& setZ(const double &dZ)
        {
                vector[2]= dZ;
                return *this;
        }

        GLC_Vector4d& setW(const double &dW);

        GLC_Vector4d& setVect(const double &dX, const double &dY, const double &dZ, const double &dW= 1);

        inline GLC_Vector4d& setVect(const GLC_Vector4d &Vect)
        {
                vector[0]= Vect.vector[0];
                vector[1]= Vect.vector[1];
                vector[2]= Vect.vector[2];
                vector[3]= Vect.vector[3];
                return *this;
        }

        GLC_Vector4d& setNormal(const double &Norme);

        inline GLC_Vector4d& invert(void)
        {
                vector[0]= - vector[0];
                vector[1]= - vector[1];
                vector[2]= - vector[2];
                return *this;
        }




public:
        inline double X(void) const
        {
                return vector[0];
        }
        inline double Y(void) const
        {
                return vector[1];
        }
        inline double Z(void) const
        {
                return vector[2];
        }
        inline double W(void) const
        {
                return vector[3];
        }
        inline GLC_Vector3d toVector3d() const
        {
                return GLC_Vector3d(vector[0], vector[1], vector[2]);
        }
        inline GLC_Vector3df toVector3df() const
        {
                return GLC_Vector3df(static_cast<float>(vector[0]), static_cast<float>(vector[1]), static_cast<float>(vector[2]));
        }
        inline const double *data(void) const
        {
                return vector;
        }
        inline double norm(void) const
        {
                return sqrt(vector[0] * vector[0] + vector[1] * vector[1]
                        + vector[2] * vector[2]);
        }
        inline bool isNull(void) const
        {
                bool result;

                result= qFuzzyCompare(vector[0], 0.0) && qFuzzyCompare(vector[1], 0.0)
                        && qFuzzyCompare(vector[2], 0.0);

                return result;
        }

        double getAngleWithVect(GLC_Vector4d Vect) const;

        QString toString() const;


        GLC_Vector2d toVector2d(const GLC_Vector4d&) const;

        inline QVector<float> toFloat3dQVector() const
        {
                QVector<float> result;
                result << static_cast<float>(vector[0]) << static_cast<float>(vector[1]) << static_cast<float>(vector[2]);
                return result;
        }

// Private services functions
private:

        void normalizeW(void);

//name Private attributes
private:
        enum {VECT4DIMENSION = 4};
        double vector[VECT4DIMENSION];

}; //class GLC_Vector4d

//typedef GLC_Vector4d GLC_Point4d;

QDataStream &operator<<(QDataStream &, const GLC_Vector4d &);
QDataStream &operator>>(QDataStream &, GLC_Vector4d &);

#endif /*GLC_VECTOR4D_H_*/