Vector.h

Aller à la documentation de ce fichier.

#ifndef API_VECTOR_H
#define API_VECTOR_H

#include <iostream>

namespace API
{
    namespace Math
    {
        template <typename T>
        struct Vector3
        {
            using component_type = T;
            T x, y, z;

            Vector3();
            Vector3(T inX, T inY, T inZ);

            Vector3(const API::Math::Vector3<T> &inVector) :
            x(inVector.x),
            y(inVector.y),
            z(inVector.z)
            {}

            Vector3(const T inScaler) :
            x(inScaler),
            y(inScaler),
            z(inScaler)
            {}

            virtual ~Vector3();

            virtual void swap(Vector3<T> &inVector)
            {
                std::swap(x, inVector.x);
                std::swap(y, inVector.y);
                std::swap(z, inVector.z);
            }

            virtual Vector3<T>& operator = (const Vector3<T> &inVector)
            {
                this->x = inVector.x;
                this->y = inVector.y;
                this->z = inVector.z;

                return *this;
            }

            virtual Vector3<T>& operator = (const T inScalar)
            {
                this->x = inScalar;
                this->y = inScalar;
                this->z = inScalar;

                return *this;
            }

            virtual bool operator == (const Vector3<T> &inVector) const
            {
                return x == inVector.x && y == inVector.y && z == inVector.z;
            }

            virtual bool operator != (const Vector3<T> &inVector) const
            {
                return x != inVector.x || y != inVector.y || z != inVector.z;
            }

            // arithmetic operations
            virtual Vector3<T> operator + (const Vector3<T> &inVector) const
            {
                return Vector3<T>(this->x + inVector.x, this->y + inVector.y, this->z + inVector.z);
            }

            virtual Vector3<T> operator - (const Vector3<T>& inVector) const
            {
                return Vector3<T>(this->x - inVector.x, this->y - inVector.y, this->z - inVector.z);
            }

            Vector3<T> operator * (const T inScalar) const
            {
                return Vector3<T>(this->x * inScalar, this->y * inScalar, this->z * inScalar);
            }

            virtual Vector3<T> operator * (const Vector3<T> &inVector) const
            {
                return Vector3<T>(inVector.x * this->x, inVector.y * this->y, inVector.y * this->z);
            }

            virtual const Vector3<T> & operator + () const
            {
                return *this;
            }

            Vector3<T> operator - () const
            {
                return Vector3<T>(-this->x, -this->y, -this->z);
            }

            inline friend Vector3<T> operator * (const T inScalar, const Vector3<T> &inVector)
            {
                return Vector3<T>(inScalar * inVector.x, inScalar * inVector.y, inScalar * inVector.z);
            }

            inline friend Vector3<T>  operator + (const Vector3<T> &inVector, const T inValue)
            {
                return Vector3<T>(inVector.x + inValue, inVector.y + inValue, inVector.z + inValue);
            }

            inline friend Vector3<T>  operator + (const T inValue, const Vector3<T> &inVector)
            {
                return Vector3<T>(inValue + inVector.x, inValue + inVector.y, inValue + inVector.z);
            }

            inline friend Vector3<T>  operator - (const Vector3<T> &inVector, T inValue)
            {
                return Vector3<T>(inVector.x - inValue, inVector.y - inValue, inVector.z - inValue);
            }

            inline friend Vector3<T> operator - (const T inValue, const Vector3<T> &inVector)
            {
                return Vector3<T>(inValue - inVector.x, inValue - inVector.y, inValue - inVector.z);
            }

            // arithmetic updates
            virtual Vector3<T>& operator += (const Vector3<T> &inVector)
            {
                this->x += inVector.x;
                this->y += inVector.y;
                this->z += inVector.z;

                return *this;
            }

            virtual Vector3<T>& operator -= (const Vector3<T> &inVector)
            {
                this->x -= inVector.x;
                this->y -= inVector.y;
                this->z -= inVector.z;

                return *this;
            }

            virtual Vector3<T>& operator *= (const T inScalar)
            {
                this->x *= inScalar;
                this->y *= inScalar;
                this->z *= inScalar;

                return *this;
            }

            virtual Vector3<T>& operator += (const T inScalar)
            {
                this->x += inScalar;
                this->y += inScalar;
                this->z += inScalar;

                return *this;
            }

            virtual Vector3<T>& operator -= (const T inScalar)
            {
                this->x -= inScalar;
                this->y -= inScalar;
                this->z -= inScalar;

                return *this;
            }

            virtual Vector3<T>& operator *= (const Vector3<T> &inVector)
            {
                this->x *= inVector.x;
                this->y *= inVector.y;
                this->z *= inVector.z;

                return *this;
            }

            inline Vector3<T>& operator /= (const Vector3<T> &inVector)
            {
                this->x /= inVector.x;
                this->y /= inVector.y;
                this->z /= inVector.z;

                return *this;
            }

            virtual T dotProduct(const Vector3 &inVec) const;

            friend std::ostream& operator << (std::ostream &inOStream, const Vector3 &inVector)
            {
                inOStream << inVector.x << ", " << inVector.y << ", " << inVector.z;
                return inOStream;
            }
        };
    }
}

#include "Vector.tpp"

#endif // API_VECTOR_H