Vector3D.h

gehe zur Dokumentation dieser Datei

#ifndef _ZFXMATH_INCLUDE_VECTOR3D_H_
#define _ZFXMATH_INCLUDE_VECTOR3D_H_

namespace ZFXMath
{

    template<typename T>
    struct TVector4D;

    template<typename T>
    struct TVector3D
    {
        union
        {
            T           val[3];
            struct
            {
                T       x, y, z;
            };
            struct
            {
                T       r, g, b;
            };
        };

        TVector3D() {};

        TVector3D( const T& _x, const T& _y, const T& _z ) { x=_x; y=_y; z=_z; }

        TVector3D( const T* pV ) { x = pV[0]; y = pV[1]; z = pV[2]; }
        TVector3D( const T& val ) { x = y = z = val; }
        TVector3D( const TVector3D& v ) { x = v.x; y = v.y; z = v.z; }
        TVector3D( const TVector2D<T>& v, const T& _z ) { x = v.x; y = v.y; z = _z; }
        TVector3D( const TVector4D<T>& v ) { x = v.x; y = v.y; z = v.z; }


        operator T* ()  { return val; }
        operator const T* () const { return val; }

        T operator () ( const int i ) const
        {
            return val[ Check( i ) ];
        }

        T& operator () ( const int i )
        {
            return val[ Check( i ) ];
        }

        TVector3D& operator = ( const T& val ) { x = y = z = val; return *this; }
        TVector3D& operator += ( const TVector3D& v ) { x += v.x; y += v.y; z += v.z; return *this; }
        TVector3D& operator -= ( const TVector3D& v ) { x -= v.x; y -= v.y; z -= v.z; return *this; }
        TVector3D& operator *= ( const TVector3D& v ) { x *= v.x; y *= v.y; z *= v.z; return *this; }
        TVector3D& operator /= ( const TVector3D& v ) { x /= v.x; y /= v.y; z /= v.z; return *this; }

        TVector3D& operator *= ( const T& v ) { x *= v; y *= v; z *= v; return *this; }
        TVector3D& operator /= ( const T& v ) { x /= v; y /= v; z /= v; return *this; }

        TVector3D operator + () const { return *this; }
        TVector3D operator - () const { return TVector3D(-x,-y,-z); }

        TVector3D operator + ( const TVector3D& v ) const { return TVector3D( x + v.x, y + v.y, z + v.z ); }
        TVector3D operator - ( const TVector3D& v ) const { return TVector3D( x - v.x, y - v.y, z - v.z ); }
        TVector3D operator * ( const TVector3D& v ) const { return TVector3D( x * v.x, y * v.y, z * v.z ); }
        TVector3D operator / ( const TVector3D& v ) const { return TVector3D( x / v.x, y / v.y, z / v.z ); }
        TVector3D operator * ( const T& v ) const { return TVector3D( x * v, y * v, z * v ); }
        TVector3D operator / ( const T& v ) const { return TVector3D( x / v, y / v, z / v ); }
        friend TVector3D<T> operator * ( const T& val, const TVector3D<T>& vec ) { return TVector3D( vec.x * val, vec.y * val, vec.z * val ); }

        unsigned long ColorToDWORD( T alpha = 1.0 )
        {
            ARGB color( r, g, b, alpha );

            return color;
        };

        unsigned long ToDWORD( T w = 0.0 )
        {
            ARGB packedVector(  x * 0.5 + 0.5,
                                y * 0.5 + 0.5,
                                z * 0.5 + 0.5,
                                w * 0.5 + 0.5 );

            return packedVector;
        };

        T LengthSqr()
        {
            return DotProduct( *this );
        };

        T Length()
        {
            return Sqrt( LengthSqr() );
        };

        TVector3D& Normalize()
        {
            return (*this) /= Length();
        };

        T DotProduct( const TVector3D& v ) const { return v.x * x + v.y * y + v.z * z; }

        T Luminance() const { return DotProduct( TVector3D( T(0.39), T(0.5), T(0.11) ) ); }

 
        TVector3D Reflect( const TVector3D& n ) const
        {
            return TVector3D( (*this) - 2 * DotProduct( n ) * n );
        }

        TVector3D Refract( const TVector3D& n, const T& ri ) const
        {
            T cos = DotProduct( n ) * ri;

            return Interpolate( (*this),  n, cos ).Normalize();
        }

    private:
        inline int Check( const int index ) const
        {
            // Check bounds in debug build
            assert( index >= 0 && index < 3 );

            return (index);
        }
    };
}

#endif //_ZFXMATH_INCLUDE_VECTOR3D_H_

---