Vec2.h

Go to the documentation of this file.

 
//
// Copyright 2020 Arvind Singh
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
//version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _TGX_VEC2_H_
#define _TGX_VEC2_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
#include <stdint.h>
#include "Misc.h"
 
namespace tgx
{
 
 
    // forward declarations
 
    template<typename T> struct Vec2;
 
    template<typename T> struct Vec3;
 
    template<typename T> struct Vec4;
 
 
    // Specializations
 
    typedef Vec2<int> iVec2; 
 
    typedef Vec2<float> fVec2; 
 
    typedef Vec2<double> dVec2; 
 
 
    template<typename T> struct Vec2
        {
 
        // mtools extension (if available).  
        #if (MTOOLS_TGX_EXTENSIONS)
        #include <mtools/extensions/tgx/tgx_ext_Vec2.inl>
        #endif
        
        // coordinates
        T x; 
        T y; 
 
 
        Vec2() {}
 
 
        constexpr Vec2(T X, T Y) : x(X), y(Y) {}
 
 
        Vec2(const Vec2 & v) = default;
 
 
        Vec2 & operator=(const Vec2 & V) = default;
 
 
        template<typename U>
        explicit operator Vec2<U>() { return Vec2<U>((U)x, (U)y); }
 
 
        operator Vec2<typename DefaultFPType<T>::fptype>() { return Vec2<typename DefaultFPType<T>::fptype>((typename DefaultFPType<T>::fptype)x, (typename DefaultFPType<T>::fptype)y); }
 
 
        inline bool operator==(const Vec2 V) const 
            {
            return ((x == V.x) && (y == V.y));
            }
 
 
        inline bool operator!=(const Vec2 V) const
            { 
            return(!(operator==(V))); 
            }
 
 
        inline bool operator<(const Vec2 V) const 
            { 
            return ((x < V.x) || ((x == V.x) && (y < V.y)));
            }
 
 
        inline bool operator<=(const Vec2 V) const
            {
            return ((x <= V.x) || ((x == V.x) && (y <= V.y)));
            }
            
 
        inline bool operator>(const Vec2 V) const 
            { 
            return(!(operator<=(V))); 
            }
 
 
        inline bool operator>=(const Vec2 V) const
            { 
            return(!(operator<(V))); 
            }
 
 
        inline void operator+=(const Vec2 V)
            { 
            x += V.x;
            y += V.y;
            }
 
 
        inline void operator-=(const Vec2 V) 
            {
            x -= V.x;
            y -= V.y;
            }
 
 
        inline void operator*=(const Vec2 V)
            {
            x *= V.x;
            y *= V.y;
            }
 
 
        inline void operator/=(const Vec2 V) 
            {
            x /= V.x;
            y /= V.y;
            }
 
 
        inline void operator+=(const T & v) 
            {
            x += v;
            y += v;
            }
 
 
        inline void operator-=(const T & v) 
            {
            x -= v;
            y -= v;
            }
 
        inline void operator*=(const T & v)
            {
            x *= v;
            y *= v;
            }
 
        inline void operator/=(const T & v)
            {
            x /= v;
            y /= v;
            }
 
 
        inline Vec2 operator-() const 
            {
            return Vec2{ -x, -y };
            }
 
 
        inline T norm2() const
            { 
            return x*x + y*y; 
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm() const
            { 
            return (Tfloat)tgx::precise_sqrt((Tfloat)(x*x + y*y));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm_fast() const
            { 
            return (Tfloat)tgx::fast_sqrt((Tfloat)(x*x + y*y));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm() const
            { 
            return (Tfloat)tgx::precise_invsqrt((Tfloat)(x*x + y*y));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm_fast() const
            { 
            return (Tfloat)tgx::fast_invsqrt((Tfloat)(x*x + y*y));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline void normalize()
            { 
            Tfloat a = invnorm<Tfloat>(); 
            x = (T)(x * a);
            y = (T)(y * a);
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline void normalize_fast()
            { 
            Tfloat a = invnorm_fast<Tfloat>(); 
            x = (T)(x * a);
            y = (T)(y * a);
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec2<T> getNormalize() const
            { 
            Vec2<T> V(*this);
            V.normalize();
            return V;
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec2<T> getNormalize_fast() const
            { 
            Vec2<T> V(*this);
            V.normalize_fast();
            return V;
            }
 
 
 
        inline void rotate90()
            { 
            *this = getRotate90(); 
            }
 
 
        inline Vec2<T> getRotate90() const
            { 
            return Vec2<T>(-y, x); 
            }
 
 
        inline int leftOf(Vec2<T> LA, Vec2<T> LB) const;
 
 
        inline bool setAsIntersection(Vec2<T> LA1, Vec2<T> LA2, Vec2<T> LB1, Vec2<T> LB2);
 
 
 
#ifdef TGX_ON_ARDUINO
 
        inline void print(Stream & outputStream = Serial) const
            {
            outputStream.printf("[%.6f \t %.6f]\n", x, y);
            }
 
#endif
 
    };
 
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline  Vec2<T> normalize(Vec2<T> V)
        {
        V.template normalize<Tfloat>();
        return V;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline  Vec2<T> normalize_fast(Vec2<T> V)
        {
        V.template normalize_fast<Tfloat>();
        return V;
        }
 
 
    template<typename T> inline T dist2(const Vec2<T>  V1, const Vec2<T>  V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        return xx * xx + yy * yy;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > Tfloat dist(Vec2<T> V1, const Vec2<T> V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        return (Tfloat)tgx::precise_sqrt((Tfloat)(xx * xx + yy * yy));
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > Tfloat dist_fast(Vec2<T> V1, const Vec2<T> V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        return (Tfloat)tgx::fast_sqrt((Tfloat)(xx * xx + yy * yy));
        }
 
 
    template<typename T> inline Vec2<T> operator+(Vec2<T> V1, const Vec2<T> V2) { V1 += V2; return V1; }
 
    template<typename T> inline Vec2<T> operator-(Vec2<T> V1, const Vec2<T> V2) { V1 -= V2; return V1; }
 
    template<typename T> inline Vec2<T> operator*(Vec2<T> V1, const Vec2<T> V2) { V1 *= V2; return V1; }
 
    template<typename T> inline Vec2<T> operator/(Vec2<T> V1, const Vec2<T> V2) { V1 /= V2; return V1; }
 
    template<typename T> inline Vec2<T> operator+(const T a, Vec2<T> V) { V += a; return V; }
 
    template<typename T> inline Vec2<T> operator+(Vec2<T> V, const T a) { V += a; return V; }
 
    template<typename T> inline Vec2<T> operator-(const T a, Vec2<T> V) { V -= a; return V; }
 
    template<typename T> inline Vec2<T> operator-(Vec2<T> V, const T a) { V -= a; return V; }
 
    template<typename T> inline Vec2<T> operator*(const T a, Vec2<T> V) { V *= a; return V; }
 
    template<typename T> inline Vec2<T> operator*(Vec2<T> V, const T a) { V *= a; return V; }
 
    template<typename T> inline Vec2<T> operator/(const T a, Vec2<T> V) { V /= a; return V; }
 
    template<typename T> inline Vec2<T> operator/(Vec2<T> V, const T a) { V /= a; return V; }
 
 
    template<typename T> inline T dotProduct(const Vec2<T> U, const Vec2<T> V)
        {
        return U.x * V.x + U.y * V.y;
        }
 
 
    template<typename T> inline T crossProduct(const Vec2<T>& U, const Vec2<T>& V)
        {
        return (U.x * V.y - U.y * V.x);
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec2<T> lerp(Tfloat alpha, Vec2<T> V1, Vec2<T> V2)
        {
        return Vec2<T>{ (T)(V1.x + alpha * (V2.x - V1.x)),
                        (T)(V1.y + alpha * (V2.y - V1.y)) };
        }
 
 
 
    template<typename T> inline int Vec2<T>::leftOf(Vec2<T> LA, Vec2<T> LB) const
        {
        T x = crossProduct(LB - LA, (*this) - LB);
        return ((x < 0) ? -1 : ((x > 0) ? 1 : 0));
        }
 
 
    template<typename T> inline bool Vec2<T>::setAsIntersection(Vec2<T> LA1, Vec2<T> LA2, Vec2<T> LB1, Vec2<T> LB2)
        {
        const T a1 = LA2.y - LA1.y;
        const T b1 = LA1.x - LA2.x;
        const T a2 = LB2.y - LB1.y;
        const T b2 = LB1.x - LB2.x;
        const T delta = a1 * b2 - a2 * b1;
        if (delta == 0) { return false; }
        const T c1 = LA1.x * a1 + LA1.y * b1;
        const T c2 = LB1.x * a2 + LB1.y * b2;
        x = ((b1 == 0) ? LA1.x : ((b2 == 0) ? LB1.x : (T)((b2 * c1 - b1 * c2) / delta)));   // complicated but insures perfect clipping
        y = ((a1 == 0) ? LA1.y : ((a2 == 0) ? LB1.y : (T)((a1 * c2 - a2 * c1) / delta)));   // for horizontal and vertical lines
        return true;
        }
 
 
 
 
 
}
 
#endif
 
#endif