Vec4.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_VEC4_H_
#define _TGX_VEC4_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
 
#include <stdint.h>
 
#include "Misc.h"
#include "Vec2.h"
#include "Vec3.h"
 
 
namespace tgx
{
 
 
    // forward declarations
 
    template<typename T> struct Vec2;    
 
    template<typename T> struct Vec3;
   
    template<typename T> struct Vec4;
 
 
    // Specializations
 
    typedef Vec4<int> iVec4; 
 
    typedef Vec4<float> fVec4; 
 
    typedef Vec4<double> dVec4; 
 
 
 
 
    template<typename T> struct Vec4 : public Vec3<T>
        {
 
        // mtools extension (if available).  
        #if (MTOOLS_TGX_EXTENSIONS)
        #include <mtools/extensions/tgx/tgx_ext_Vec4.inl>
        #endif
 
 
        // first three coordinates from base classes
        using Vec2<T>::x;
        using Vec2<T>::y;
        using Vec3<T>::z;
 
        // and the new fourth coordinates
        T w; 
 
 
        Vec4() {}
 
 
        constexpr Vec4(T X, T Y, T Z, T W) : Vec3<T>(X,Y,Z), w(W)
            {
            }
 
 
        Vec4(const Vec4 & V) = default;
 
 
        constexpr Vec4(Vec2<T> V, T Z, T W) : Vec3<T>(V, Z), w(W)
            {
            }
 
 
        constexpr Vec4(Vec3<T> V, T W) : Vec3<T>(V), w(W)
            {
            }
 
 
        Vec4 & operator=(const Vec4 & V) = default;
 
 
        template<typename U>
        explicit operator Vec4<U>() { return Vec4<U>((U)x, (U)y, (U)z, (U)w); }
 
 
        operator Vec4<typename DefaultFPType<T>::fptype>() { return Vec4<typename DefaultFPType<T>::fptype>((typename DefaultFPType<T>::fptype)x, (typename DefaultFPType<T>::fptype)y, (typename DefaultFPType<T>::fptype)z, (typename DefaultFPType<T>::fptype)w); }
 
 
        inline bool operator==(const Vec4 V) const
            {
            return ((x == V.x) && (y == V.y) && (z == V.z) && (w == V.w));
            }
 
 
        inline bool operator!=(const Vec4 V) const
            { 
            return(!(operator==(V))); 
            }
 
 
        inline bool operator<(const Vec4 V) const
            { 
            if (x < V.x) return true;
            if (x == V.x)
                {
                if (y < V.y) return true;
                if (y == V.y)
                    {
                    if (z < V.z) return true;
                    if (z == V.z) return true;
                        {
                        if (w < V.w) return true;
                        }
                    }
                }
            return false;
            }
 
 
        inline bool operator<=(const Vec4 V) const
            {
            if (x < V.x) return true;
            if (x == V.x)
                {
                if (y < V.y) return true;
                if (y == V.y)
                    {
                    if (z < V.z) return true;
                    if (z == V.z) return true;
                        {
                        if (w <= V.w) return true;
                        }
                    }
                }
            return false;
            }
            
 
        inline bool operator>(const Vec4 V) const 
            { 
            return(!(operator<=(V))); 
            }
 
 
        inline bool operator>=(const Vec4 V) const
            { 
            return(!(operator<(V))); 
            }
 
 
        inline void operator+=(const Vec4 V)
            { 
            x += V.x;
            y += V.y;
            z += V.z;
            w += V.w;
            }
 
 
        inline void operator-=(const Vec4 V) 
            {
            x -= V.x;
            y -= V.y;
            z -= V.z;
            w -= V.w;
            }
 
 
        inline void operator*=(const Vec4 V) 
            {
            x *= V.x;
            y *= V.y;
            z *= V.z;
            w *= V.w;
            }
 
 
        inline void operator/=(const Vec4 V)
            {
            x /= V.x;
            y /= V.y;
            z /= V.z;
            w /= V.w;
            }
 
 
        inline void operator+=(const T v) 
            {
            x += v;
            y += v;
            z += v;
            w += v;
            }
 
 
        inline void operator-=(const T v) 
            {
            x -= v;
            y -= v;
            z -= v;
            w -= v;
            }
 
        inline void operator*=(const T v) 
            {
            x *= v;
            y *= v;
            z *= v;
            w *= v;
            }
 
        inline void operator/=(const T v) 
            {
            x /= v;
            y /= v;
            z /= v;
            w /= v;
            }
 
 
       
      //  DO NOT DEFINE FOR PROJECTIVE VECTORS 
      //  TO PREVENT SPUPID MISTAKES WHEN CASTING...       
      //  inline Vec4 operator-() const
      //      {
      //      return Vec4{ -x, -y, -z, w };
      //      }
 
 
        inline T norm2() const 
            { 
            return x*x + y*y +z*z +w*w; 
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm() const
            { 
            return (Tfloat)tgx::precise_sqrt((Tfloat)(x*x + y*y + z*z + w*w));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm_fast() const
            { 
            return (Tfloat)tgx::fast_sqrt((Tfloat)(x*x + y*y + z*z + w*w));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm() const
            { 
            return (Tfloat)tgx::precise_invsqrt((Tfloat)(x*x + y*y + z*z + w*w));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm_fast() const
            { 
            return (Tfloat)tgx::fast_invsqrt((Tfloat)(x*x + y*y + z*z + w*w));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline void normalize()
            { 
            Tfloat a = invnorm<Tfloat>(); 
            x = (T)(x * a);
            y = (T)(y * a);
            z = (T)(z * a);
            w = (T)(w * 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);
            z = (T)(z * a);
            w = (T)(w * a);
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec4<T> getNormalize() const
            { 
            Vec4<T> V(*this);
            V.normalize();
            return V;
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec4<T> getNormalize_fast() const
            { 
            Vec4<T> V(*this);
            V.normalize_fast();
            return V;
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline void zdivide() 
            {
            const float iw = tgx::fast_inv(w);
            x = iw*x;
            y = iw*y;
            z = iw*z;
            w = iw;
            }
 
 
#ifdef TGX_ON_ARDUINO
 
        inline void print(Stream & outputStream = Serial) const
            {
            outputStream.printf("[%.3f \t %.3f \t %.3f \t %.3f]\n", x, y, z, w);
            }
 
#endif 
 
    };
 
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline  Vec4<T> normalize(Vec4<T> V)
        {
        V.template normalize<Tfloat>();
        return V;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline  Vec4<T> normalize_fast(Vec4<T> V)
        {
        V.template normalize_fast<Tfloat>();
        return V;
        }
 
 
    template<typename T> inline T dist2(const Vec4<T>  V1, const Vec4<T>  V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        const T ww = V1.w - V2.w;
        return xx * xx + yy * yy + zz * zz + ww * ww;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > Tfloat dist(Vec4<T> V1, const Vec4<T> V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        const T ww = V1.w - V2.w;
        return (Tfloat)tgx::precise_sqrt((Tfloat)(xx * xx + yy * yy + zz * zz + ww * ww));
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > Tfloat dist_fast(Vec4<T> V1, const Vec4<T> V2)
        {
        const T xx = V1.x - V2.y;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        const T ww = V1.w - V2.w;
        return (Tfloat)tgx::fast_sqrt((Tfloat)(xx * xx + yy * yy + zz * zz + ww * ww));
        }
 
 
    template<typename T> inline Vec4<T> operator+(Vec4<T> V1, const Vec4<T> V2) { V1 += V2; return V1; }
 
    template<typename T> inline Vec4<T> operator-(Vec4<T> V1, const Vec4<T> V2) { V1 -= V2; return V1; }
 
    template<typename T> inline Vec4<T> operator*(Vec4<T> V1, const Vec4<T> V2) { V1 *= V2; return V1; }
 
    template<typename T> inline Vec4<T> operator/(Vec4<T> V1, const Vec4<T> V2) { V1 /= V2; return V1; }
 
    template<typename T> inline Vec4<T> operator+(const T a, Vec4<T> V) { V += a; return V; }
 
    template<typename T> inline Vec4<T> operator+(Vec4<T> V, const T a) { V += a; return V; }
 
    template<typename T> inline Vec4<T> operator-(const T a, Vec4<T> V) { V -= a; return V; }
 
    template<typename T> inline Vec4<T> operator-(Vec4<T> V, const T a) { V -= a; return V; }
 
    template<typename T> inline Vec4<T> operator*(const T a, Vec4<T> V) { V *= a; return V; }
 
    template<typename T> inline Vec4<T> operator*(Vec4<T> V, const T a) { V *= a; return V; }
 
    template<typename T> inline Vec4<T> operator/(const T a, Vec4<T> V) { V /= a; return V; }
 
    template<typename T> inline Vec4<T> operator/(Vec4<T> V, const T a) { V /= a; return V; }
 
 
    template<typename T> inline T dotProduct(const Vec4<T> U, const Vec4<T> V)
        {
        return U.x * V.x + U.y * V.y + U.z * V.z + U.w * V.w;
        }
 
 
    template<typename T> inline Vec4<T> crossProduct(const Vec4<T>& U, const Vec4<T>& V)
        {
        return Vec4<T>{ U.y* V.z - U.z * V.y,
                        U.z* V.x - U.x * V.z,
                        U.x* V.y - U.y * V.x,
                        0 };
        }
 
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec4<T> lerp(Tfloat alpha, Vec4<T> V1, Vec4<T> V2)
        {
        return Vec4<T>{ (T)(V1.x + alpha * (V2.x - V1.x)),
                        (T)(V1.y + alpha * (V2.y - V1.y)),
                        (T)(V1.z + alpha * (V2.z - V1.z)),
                        (T)(V1.w + alpha * (V2.w - V1.w)) };
        }
 
 
}
 
#endif
 
#endif