Vec3.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_VEC3_H_
#define _TGX_VEC3_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
#include <stdint.h>
 
#include "Misc.h"
#include "Vec2.h"
 
 
namespace tgx
{
 
 
    // forward declarations
 
    template<typename T> struct Vec2;
    
    template<typename T> struct Vec3;
 
    template<typename T> struct Vec4;
 
 
    // Specializations 
 
    typedef Vec3<int> iVec3; 
 
    typedef Vec3<float> fVec3; 
 
    typedef Vec3<double> dVec3; 
 
 
 
 
 
    template<typename T> struct Vec3 : public Vec2<T>
        {
 
        // mtools extension (if available).  
        #if (MTOOLS_TGX_EXTENSIONS)
        #include <mtools/extensions/tgx/tgx_ext_Vec3.inl>
        #endif
        
        
        // first two coordinates from the base class
        using Vec2<T>::x;
        using Vec2<T>::y;
 
        // and the new third coordinates
        T z; 
 
 
        Vec3() {}
 
 
        constexpr Vec3(T X, T Y, T Z) : Vec2<T>(X,Y), z(Z)
            {
            }
 
 
        Vec3(const Vec3 & V) = default;
 
 
        constexpr Vec3(Vec2<T> V, T Z) : Vec2<T>(V), z(Z)
            {
            }
 
 
        Vec3 & operator=(const Vec3 & V) = default;
 
 
        template<typename U>
        explicit operator Vec3<U>() const { return Vec3<U>((U)x, (U)y, (U)z); }
 
 
        operator Vec3<typename DefaultFPType<T>::fptype>() const { return Vec3<typename DefaultFPType<T>::fptype>((typename DefaultFPType<T>::fptype)x, (typename DefaultFPType<T>::fptype)y, (typename DefaultFPType<T>::fptype)z); }
 
 
 
        inline bool operator==(const Vec3 & V) const
            {
            return ((x == V.x) && (y == V.y) && (z == V.z));
            }
 
 
        inline bool operator!=(const Vec3 & V) const
            { 
            return(!(operator==(V))); 
            }
 
 
        inline bool operator<(const Vec3 & 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;                    
                    }
                }
            return false;
            }
 
 
        inline bool operator<=(const Vec3 & 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;
                    }
                }
            return false;
            }
            
 
        inline bool operator>(const Vec3 & V) const
            {
            return(!(operator<=(V)));
            }
 
 
        inline bool operator>=(const Vec3 & V) const
            {
            return(!(operator<(V)));
            }
 
 
        TGX_INLINE inline void operator+=(const Vec3 & V)
            {
            x += V.x;
            y += V.y;
            z += V.z;
            }
 
 
        TGX_INLINE inline void operator-=(const Vec3 & V)
            {
            x -= V.x;
            y -= V.y;
            z -= V.z;
            }
 
 
        TGX_INLINE inline void operator*=(const Vec3 & V)
            {
            x *= V.x;
            y *= V.y;
            z *= V.z;
            }
 
 
        TGX_INLINE inline void operator/=(const Vec3 & V)
            {
            x /= V.x;
            y /= V.y;
            z /= V.z;
            }
 
 
        TGX_INLINE inline void operator+=(T v)
            {
            x += v;
            y += v;
            z += v;
            }
 
 
        TGX_INLINE inline void operator-=(T v)
            {
            x -= v;
            y -= v;
            z -= v;
            }
 
        TGX_INLINE inline void operator*=(T v)
            {
            x *= v;
            y *= v;
            z *= v;
            }
 
        TGX_INLINE inline void operator/=(T v)
            {
            x /= v;
            y /= v;
            z /= v;
            }
 
 
        inline Vec3 operator-() const
            {
            return Vec3{ -x, -y, -z };
            }
 
 
 
        inline T norm2() const
            { 
            return x*x + y*y +z*z; 
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm() const
            { 
            return (Tfloat)tgx::precise_sqrt((Tfloat)(x*x + y*y +z*z));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat norm_fast() const
            { 
            return (Tfloat)tgx::fast_sqrt((Tfloat)(x*x + y*y +z*z));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm() const
            { 
            return (Tfloat)tgx::precise_invsqrt((Tfloat)(x*x + y*y +z*z));
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Tfloat invnorm_fast() const
            { 
            return (Tfloat)tgx::fast_invsqrt((Tfloat)(x*x + y*y +z*z));
            }
 
 
        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);
            }
 
 
        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);
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec3<T> getNormalize() const
            { 
            Vec3<T> V(*this);
            V.normalize();
            return V;
            }
 
 
        template<typename Tfloat = typename DefaultFPType<T>::fptype > inline Vec3<T> getNormalize_fast() const
            { 
            Vec3<T> V(*this);
            V.normalize_fast();
            return V;
            }
 
 
 
#ifdef TGX_ON_ARDUINO
 
        inline void print(Stream & outputStream = Serial) const
            {
            outputStream.printf("[%.3f \t %.3f \t %.3f]\n", x, y, z);
            }
#endif
 
 
    };
 
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > TGX_INLINE inline  Vec3<T> normalize(Vec3<T> V)
        {
        V.template normalize<Tfloat>();
        return V;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > TGX_INLINE inline  Vec3<T> normalize_fast(Vec3<T> V)
        {
        V.template normalize_fast<Tfloat>();
        return V;
        }
 
 
    template<typename T> TGX_INLINE inline T dist2(const Vec3<T> & V1, const Vec3<T> & V2)
        {
        const T xx = V1.x - V2.x;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        return xx * xx + yy * yy + zz * zz;
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > TGX_INLINE inline Tfloat dist(const Vec3<T> & V1, const Vec3<T> & V2)
        {
        const T xx = V1.x - V2.x;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        return (Tfloat)tgx::precise_sqrt((Tfloat)(xx * xx + yy * yy + zz * zz));
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > TGX_INLINE inline Tfloat dist_fast(const Vec3<T> & V1, const Vec3<T> & V2)
        {
        const T xx = V1.x - V2.x;
        const T yy = V1.y - V2.y;
        const T zz = V1.z - V2.z;
        return (Tfloat)tgx::fast_sqrt((Tfloat)(xx * xx + yy * yy + zz * zz));
        }
 
 
    template<typename T> TGX_INLINE inline Vec3<T> operator+(Vec3<T> V1, const Vec3<T> & V2) { V1 += V2; return V1; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator-(Vec3<T> V1, const Vec3<T> & V2) { V1 -= V2; return V1; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator*(Vec3<T> V1, const Vec3<T> & V2) { V1 *= V2; return V1; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator/(Vec3<T> V1, const Vec3<T> & V2) { V1 /= V2; return V1; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator+(const T a, Vec3<T> V) { V += a; return V; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator+(Vec3<T> V, const T a) { V += a; return V; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator-(Vec3<T> V, const T a) { V -= a; return V; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator*(const T a, Vec3<T> V) { V *= a; return V; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator*(Vec3<T> V, const T a) { V *= a; return V; }
 
    template<typename T> TGX_INLINE inline Vec3<T> operator/(Vec3<T> V, const T a) { V /= a; return V; }
 
 
    template<typename T> TGX_INLINE inline T dotProduct(const Vec3<T> & U, const Vec3<T> & V)
        {
        return U.x * V.x + U.y * V.y + U.z * V.z;
        }
 
#if TGX_USE_FMA_MATH
    TGX_INLINE inline float dotProduct(const Vec3<float>& U, const Vec3<float>& V)
        {
        return fmaf(U.x, V.x, fmaf(U.y, V.y, U.z * V.z));
        }
#endif
 
 
    template<typename T> TGX_INLINE inline Vec3<T> crossProduct(const Vec3<T>& U, const Vec3<T>& V)
        {
        return Vec3<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 };
        }
 
 
    template<typename T, typename Tfloat = typename DefaultFPType<T>::fptype > TGX_INLINE inline Vec3<T> lerp(const Tfloat alpha, const Vec3<T> & V1, const Vec3<T> & V2)
        {
        return Vec3<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)) };
        }
 
 
}
 
#endif
 
#endif