Vec3.hpp

#ifndef VEC3_H
#define VEC3_H
 
#ifndef INCLUDE_MATH_H
#    include <cmath>
#    define INCLUDE_MATH_H
#endif
#ifndef INCLUDE_ALGORITHM_H
#    include <algorithm>
#    define INCLUDE_ALGORITHM_H
#endif
 
struct Vec3
{
    float x, y, z;
 
    static Vec3 Cross( const Vec3& v1, const Vec3& v2 )
    {
        return Vec3( v1.y * v2.z - v1.z * v2.y,
                     v1.z * v2.x - v1.x * v2.z,
                     v1.x * v2.y - v1.y * v2.x );
    }
 
    static float Distance( const Vec3& v1, const Vec3& v2 )
    {
        return (v2 - v1).Length();
    }
 
    static float DistanceSquared( const Vec3& v1, const Vec3& v2 )
    {
        const Vec3 sub = v2 - v1;
        return sub.x * sub.x + sub.y * sub.y + sub.z * sub.z;
    }
 
    static float Dot( const Vec3& v1, const Vec3& v2 )
    {
        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
    }
 
    static Vec3 Min2( const Vec3& v1, const Vec3& v2 )
    {
        return Vec3( std::min( v1.x, v2.x ), std::min( v1.y, v2.y ), std::min( v1.z, v2.z ) );
    }
 
    static Vec3 Max2( const Vec3& v1, const Vec3& v2 )
    {
        return Vec3( std::max( v1.x, v2.x ), std::max( v1.y, v2.y ), std::max( v1.z, v2.z ) );
    }
 
    static Vec3 Reflect( const Vec3& vec, const Vec3& normal ) { return vec - normal * Dot( normal, vec ) * 2; }
 
    inline Vec3( const Vec3& other ) = default;
 
    inline Vec3() : x( 0 ), y( 0 ), z( 0 ) {}
 
    inline Vec3( float ax, float ay, float az ) : x( ax ), y( ay ), z( az ) {}
 
    bool IsAlmost( const Vec3& v ) const
    {
        const float acceptableDelta = 0.0001f;
        if (std::fabs( x - v.x ) > acceptableDelta) { return false; }
        if (std::fabs( y - v.y ) > acceptableDelta) { return false; }
        if (std::fabs( z - v.z ) > acceptableDelta) { return false; }
        return true;
    }
 
    inline Vec3 operator/( float f ) const
    {
        const float inv = 1.0f / f;
        return Vec3( x * inv, y * inv, z * inv );
    }
 
    inline Vec3 operator/( const Vec3& v ) const
    {
        return Vec3( x / v.x, y / v.y, z / v.z );
    }
 
    inline Vec3 operator-() const
    {
        return Vec3( -x, -y, -z );
    }
 
    inline Vec3 operator-( const Vec3& v ) const
    {
        return Vec3( x - v.x, y - v.y, z - v.z );
    }
 
    inline Vec3 operator+( const Vec3& v ) const
    {
        return Vec3( x + v.x, y + v.y, z + v.z );
    }
 
    inline Vec3 operator+( float f ) const
    {
        return Vec3( x + f, y + f, z + f );
    }
 
    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 x != v.x || y != v.y || z != v.z;
    }
 
    inline Vec3& operator-=( const Vec3& v )
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        
        return *this;
    }
 
    inline Vec3& operator+=( const Vec3& v )
    {
        x += v.x;
        y += v.y;
        z += v.z;
 
        return *this;
    }
 
    inline Vec3& operator*=( float f )
    {
        x *= f;
        y *= f;
        z *= f;
        
        return *this;
    }
 
    inline Vec3& operator/=(float f)
    {
        const float inv = 1.0f / f;
 
        x *= inv;
        y *= inv;
        z *= inv;
 
        return *this;
    }
 
    inline Vec3& operator*=( const Vec3& v )
    {
        x *= v.x;
        y *= v.y;
        z *= v.z;
        
        return *this;
    }
 
    inline Vec3& operator=( const Vec3& v ) { x = v.x; y = v.y; z = v.z; return *this; }
 
    inline Vec3 operator*( const Vec3& v ) const
    {
        return Vec3( x * v.x, y * v.y, z * v.z );
    }
 
    inline Vec3 operator*( float f ) const
    {
        return Vec3( x * f, y * f, z * f );
    }
 
    inline Vec3 Normalized() const
    {
        Vec3 out = *this;
        
        const float len = Length();
 
        if( std::abs( len ) < 0.0001f )
        {
            out.x = 1.0f;
            out.y = 0.0f;
            out.z = 0.0f;
            return out;
        }
 
        out *= (1.0f / len);
        return out;
    }
 
    inline float Length() const { return std::sqrt( x * x + y * y + z * z ); }
    
    inline void Zero() { x = y = z = 0; }
};
 
#if defined( _MSC_VER ) || defined( COMPILER_INTEL )
#       define BEGIN_ALIGNED( n, a )                            __declspec( align( a ) ) n
#       define END_ALIGNED( n, a )
#elif defined( __GNUC__ ) || defined( __clang__ )
#       define BEGIN_ALIGNED( n, a )                            n
#       define END_ALIGNED( n, a )                              __attribute__( (aligned( a ) ) )
#endif
 
#ifdef SIMD_SSE3
struct BEGIN_ALIGNED( Vec4, 16 )
#else
struct Vec4
#endif
{
    float x, y, z, w;
 
    inline Vec4() : x( 0 ), y( 0 ), z( 0 ), w( 0 ) {}
 
    inline Vec4( float ax, float ay, float az, float aw ) : x( ax ), y( ay ), z( az ), w( aw ) {}
 
    inline explicit Vec4( const Vec3& v ) : x( v.x ), y( v.y ), z( v.z ), w( 1 ) {}
 
    inline Vec4( const Vec3& v, float aW ) : x( v.x ), y( v.y ), z( v.z ), w( aW ) {}
 
    inline Vec4 operator*( float f ) const
    {
        return Vec4( x * f, y * f, z * f, w * f );
    }
 
    inline Vec4& operator+=( const Vec4& v )
    {
        x += v.x;
        y += v.y;
        z += v.z;
 
        return *this;
    }
 
    inline Vec4& operator-=( const Vec4& v )
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
 
        return *this;
    }
 
    inline float Dot( const Vec4& v ) const
    {
        return x * v.x + y * v.y + z * v.z + w * v.w;
    }
 
    inline float Length() const { return std::sqrt( x * x + y * y + z * z ); }
 
    inline void Normalize()
    {
        const float len = Length();
 
        if( std::abs( len ) < 0.0001f )
        {
            x = 1;
            y = 0;
            z = 0;
            return;
        }
 
        const float iLength = 1 / len;
 
        x *= iLength;
        y *= iLength;
        z *= iLength;
    }
}
#ifdef SIMD_SSE3
END_ALIGNED( Vec4, 16 )
#endif
;
 
#endif