Vector2D.hpp

Go to the documentation of this file.

#include <etk/math/Vector3D.hpp>
#include <etk/types.hpp>

#pragma once

#include <cmath>

namespace etk {
    template <typename T> class Vector2D {
        public:
            T m_floats[2]; 
        public:
            /* ****************************************************
             *    Constructor
             *****************************************************/
            Vector2D() {
                #ifdef DEBUG
                    // in debug mode we set supid value to prevent forget of the inits ...
                    m_floats[0] = (T)34673363;
                    m_floats[1] = (T)34523535;
                #endif
            }
            Vector2D(T _xxx, T _yyy) {
                m_floats[0] = _xxx;
                m_floats[1] = _yyy;
            }
            Vector2D(const Vector2D<double>& _obj) {
                m_floats[0] = (T)_obj.x();
                m_floats[1] = (T)_obj.y();
            }
            Vector2D(const Vector2D<float>& _obj) {
                m_floats[0] = (T)_obj.x();
                m_floats[1] = (T)_obj.y();
            }
            Vector2D(const Vector2D<int32_t>& _obj) {
                m_floats[0] = (T)_obj.x();
                m_floats[1] = (T)_obj.y();
            }
            Vector2D(const std::string& _str);
            #if __CPP_VERSION__ >= 2011
                Vector2D(const std::u32string& _str);
            #endif

            const Vector2D<T>& operator= (const Vector2D<T>& _obj ) {
                m_floats[0] = _obj.m_floats[0];
                m_floats[1] = _obj.m_floats[1];
                return *this;
            }
            const Vector2D<T>& operator= (const T _val ) {
                m_floats[0] = _val;
                m_floats[1] = _val;
                return *this;
            }
            bool operator== (const Vector2D<T>& _obj) const {
                return (    (T)_obj.m_floats[0] == m_floats[0]
                         && (T)_obj.m_floats[1] == m_floats[1]);
            }
            bool operator!= (const Vector2D<T>& _obj) const {
                return (    (T)_obj.m_floats[0] != m_floats[0]
                         || (T)_obj.m_floats[1] != m_floats[1]);
            }
            const Vector2D<T>& operator+= (const Vector2D<T>& _obj) {
                m_floats[0] += _obj.m_floats[0];
                m_floats[1] += _obj.m_floats[1];
                return *this;
            }
            const Vector2D<T>& operator+= (const T _val) {
                m_floats[0] += _val;
                m_floats[1] += _val;
                return *this;
            }
            Vector2D<T> operator+ (const Vector2D<T>& _obj) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] += _obj.m_floats[0];
                tmpp.m_floats[1] += _obj.m_floats[1];
                return tmpp;
            }
            Vector2D<T> operator+ (const T _val) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] += _val;
                tmpp.m_floats[1] += _val;
                return tmpp;
            }
            const Vector2D<T>& operator-= (const Vector2D<T>& _obj) {
                m_floats[0] -= _obj.m_floats[0];
                m_floats[1] -= _obj.m_floats[1];
                return *this;
            }
            const Vector2D<T>& operator-= (const T _val) {
                m_floats[0] -= _val;
                m_floats[1] -= _val;
                return *this;
            }
            Vector2D<T> operator- (const Vector2D<T>& _obj) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] -= _obj.m_floats[0];
                tmpp.m_floats[1] -= _obj.m_floats[1];
                return tmpp;
            }
            Vector2D<T> operator- (const T _val) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] -= _val;
                tmpp.m_floats[1] -= _val;
                return tmpp;
            }
            const Vector2D<T>& operator*= (const Vector2D<T>& _obj) {
                m_floats[0] *= _obj.m_floats[0];
                m_floats[1] *= _obj.m_floats[1];
                return *this;
            }
            const Vector2D<T>& operator*= (const T _val) {
                m_floats[0] *= _val;
                m_floats[1] *= _val;
                return *this;
            }
            Vector2D<T> operator* (const Vector2D<T>& _obj) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] *= _obj.m_floats[0];
                tmpp.m_floats[1] *= _obj.m_floats[1];
                return tmpp;
            }
            Vector2D<T> operator* (const T _val) const {
                Vector2D<T> tmpp(m_floats[0],m_floats[1]);
                tmpp.m_floats[0] *= _val;
                tmpp.m_floats[1] *= _val;
                return tmpp;
            }
            Vector2D<T> operator/ (const Vector2D<T>& _obj) const{
                Vector2D<T> tmpp(m_floats[0], m_floats[1]);
                tmpp.m_floats[0] /= _obj.m_floats[0];
                tmpp.m_floats[1] /= _obj.m_floats[1];
                return tmpp;
            }
            Vector2D<T> operator/ (const T _val) const {
                Vector2D<T> tmpp(m_floats[0], m_floats[1]);
                tmpp.m_floats[0] /= _val;
                tmpp.m_floats[1] /= _val;
                return tmpp;
            }
            const Vector2D<T>& operator/= (const Vector2D<T>& _obj) {
                m_floats[0] /= _obj.m_floats[0];
                m_floats[1] /= _obj.m_floats[1];
                return *this;
            }
            const Vector2D<T>& operator/= (const T _val) {
                m_floats[0] /= _val;
                m_floats[1] /= _val;
                return *this;
            }
            Vector2D<T>& operator++() {
                ++m_floats[0];
                ++m_floats[1];
                return *this;
            }
            Vector2D<T> operator++(int) {
                Vector2D<T> result = *this;
                ++(*this);
                return result;
            }
            Vector2D<T>& operator--() {
                --m_floats[0];
                --m_floats[1];
                return *this;
            }
            Vector2D<T> operator--(int) {
                Vector2D<T> result = *this;
                --(*this);
                return result;
            }
            T cross(const Vector2D<T>& _obj) const {
                return   m_floats[0] * _obj.m_floats[1]
                       - m_floats[1] * _obj.m_floats[0];
            }
            T dot(const Vector2D<T>& _obj) const {
                return   m_floats[0] * _obj.m_floats[0]
                       + m_floats[1] * _obj.m_floats[1];
            }
            T length2() const {
                return dot(*this);
            }
            float length() const {
                #if __CPP_VERSION__ >= 2011 && !defined(__STDCPP_LLVM__)
                    return std::sqrt(length2());
                #else
                    return sqrt(length2());
                #endif
            }
            T distance2(const Vector2D<T>& _obj) const {
                return (_obj - *this).length2();
            }
            float distance(const Vector2D<T>& _obj) const {
                return (_obj - *this).length();
            }
            Vector2D<T>& normalize() {
                *this /= length();
                return *this;
            }
            Vector2D<T>& safeNormalize() {
                T tmp = length();
                if (tmp != 0) {
                    *this /= length();
                    return *this;
                }
                setValue(1,0);
                return *this;
            }
            Vector2D<T> normalized() const {
                return *this / length();
            }
            Vector2D<T> absolute() const {
                return Vector2D<T>( abs(m_floats[0]),
                                    abs(m_floats[1]));
            }
            int32_t minAxis() const {
                return m_floats[0] < m_floats[1] ? 0 : 1;
            }
            int32_t maxAxis() const {
                return m_floats[0] < m_floats[1] ? 1 : 0;
            }
            int32_t furthestAxis() const {
                return absolute().minAxis();
            }
            int32_t closestAxis() const {
                return absolute().maxAxis();
            }
            const T& getX() const {
                return m_floats[0];
            }
            const T& getY() const {
                return m_floats[1];
            }
            void setX(T _xxx) {
                m_floats[0] = _xxx;
            };
            void setY(T _yyy) {
                m_floats[1] = _yyy;
            };
            const T& x() const {
                return m_floats[0];
            }
            const T& y() const {
                return m_floats[1];
            }
            operator T *() {
                return &m_floats[0];
            }
            operator const T *() const {
                return &m_floats[0];
            }
            void setMax(const Vector2D<T>& _other) {
                m_floats[0] = std::max(m_floats[0], _other.m_floats[0]);
                m_floats[1] = std::max(m_floats[1], _other.m_floats[1]);
            }
            void setMin(const Vector2D<T>& _other) {
                m_floats[0] = std::min(m_floats[0], _other.m_floats[0]);
                m_floats[1] = std::min(m_floats[1], _other.m_floats[1]);
            }
            void setValue(const T& _xxx, const T& _yyy) {
                m_floats[0] = _xxx;
                m_floats[1] = _yyy;
            }
            void setZero() {
                setValue(0,0);
            }
            bool isZero() const {
                return    m_floats[0] == 0
                       && m_floats[1] == 0;
            }
            operator std::string() const;
            #if __CPP_VERSION__ >= 2011

                operator std::u32string() const;
            #endif
    };
    std::ostream& operator <<(std::ostream& _os, const etk::Vector2D<int32_t>& _obj);
    std::ostream& operator <<(std::ostream& _os, const etk::Vector2D<float>& _obj);
    std::ostream& operator <<(std::ostream& _os, const etk::Vector2D<uint32_t>& _obj);
    std::ostream& operator <<(std::ostream& _os, const etk::Vector2D<bool>& _obj);
};
// To siplify the writing of the code ==> this permit to have the same name with the glsl language...
using   vec2 = etk::Vector2D<float>;
using  ivec2 = etk::Vector2D<int32_t>;
// not compatible with glsl ... but it is better to have a same writing
using uivec2 = etk::Vector2D<uint32_t>;
using  bvec2 = etk::Vector2D<bool>; 

inline vec2 vec2ClipInt32(const vec2& _val) {
    return vec2((int32_t)_val.x(), (int32_t)_val.y());
}
inline vec2 vec2ClipInt64(const vec2& _val) {
    return vec2((int64_t)_val.x(), (int64_t)_val.y());
}

vec2 vec2rotate(const vec2& _obj, const vec2& _point, float _angle);

namespace etk {
    std::ostream& operator <<(std::ostream& _os, const std::vector<vec2 >& _obj);
    std::ostream& operator <<(std::ostream& _os, const std::vector<ivec2 >& _obj);
    std::ostream& operator <<(std::ostream& _os, const std::vector<uivec2 >& _obj);
    std::ostream& operator <<(std::ostream& _os, const std::vector<bvec2 >& _obj);
}