vector3.h

Go to the documentation of this file.

#pragma once
 
#include <adtf_utils.h>
#include <adtfdisplaytoolboxgraphics/vector3_intf.h>
 
#include <math.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{

class cVector3 : public IVector3
{
private:
    tFloat64 x; 
    tFloat64 y; 
    tFloat64 z; 
 
    static const tFloat64 nullScalar; 
    static const tFloat64 oneScalar; 
 
public:
    static const cVector3 Null; 
    static const cVector3 One; 
 
public:
    cVector3()
    {
        Zero();
    }

    cVector3(const IVector3* pVector3)
    {
        Set(pVector3->GetX(), pVector3->GetY(), pVector3->GetZ());
    }

    cVector3(const tFloat64 f64X, const tFloat64 f64Y, const tFloat64 f64Z)
    {
        Set(f64X, f64Y, f64Z);
    }

    tVoid Release()
    {
        delete this;
    }

    OPT_INLINE void Set(const cVector3& Vector)
    {
        x = Vector.x;
        y = Vector.y;
        z = Vector.z;
    }

    OPT_INLINE void Set(const tFloat64 Value)
    {
        x = y = z = Value;
    }

    OPT_INLINE void Set(const tFloat64 f64X, const tFloat64 f64Y, const tFloat64 f64Z)
    {
        x = f64X;
        y = f64Y;
        z = f64Z;
    }

    OPT_INLINE void Zero()
    {
        x = y = z = 0.0;
    }

    OPT_INLINE void Add(const cVector3& Vector)
    {
        x += Vector.x;
        y += Vector.y;
        z += Vector.z;
    }

    OPT_INLINE void Sub(const cVector3& Vector)
    {
        x -= Vector.x;
        y -= Vector.y;
        z -= Vector.z;
    }

    OPT_INLINE void Scale(const tFloat64 Value)
    {
        x *= Value;
        y *= Value;
        z *= Value;
    }

    OPT_INLINE void Scale(const cVector3& Vector)
    {
        x *= Vector.x;
        y *= Vector.y;
        z *= Vector.z;
    }
 
    // void Rotate(const cVector3& Vector);

    OPT_INLINE cVector3 Scalar(const cVector3& Vector) const
    {
        return cVector3(x * Vector.x, y * Vector.y, z * Vector.z);
    }

    OPT_INLINE cVector3 Multiply(const cVector3& Vector) const
    {
        return *this * Vector;
    }
 
    // OPT_INLINE cVector3 Multiply(const cMatrix& Matrix) const;

    tFloat Length() const
    {
        return (tFloat64) sqrt(x * x + y * y + z * z);
    }

    void Normalize()
    {
        tFloat64 len = Length();
 
        if (len > 0)
        {
            x /= len;
            y /= len;
            z /= len;
        }
        else
            x = y = z = 0.0;
    }

    void Dump()
    {
        /*
         * Using the largest available float type is compatible with all
         * definitions of 'tScalar'.
         */
        printf("%05.2f\n", x);
        printf("%05.2f\n", y);
        printf("%05.2f\n", z);
    }

    tFloat64 GetX() const
    {
        return x;
    }

    tVoid SetX(tFloat64 f64XValue)
    {
        x = f64XValue;
    }

    tFloat64 GetY() const
    {
        return y;
    }

    tVoid SetY(tFloat64 f64YValue)
    {
        y = f64YValue;
    }

    tFloat64 GetZ() const
    {
        return z;
    }

    tVoid SetZ(tFloat64 f64ZValue)
    {
        z = f64ZValue;
    }

    cVector3 operator=(const cVector3& v)
    {
        Set(v.x, v.y, v.z);
 
        return *this;
    }

    cVector3 operator-(void)
    {
        return cVector3(-x, -y, -z);
    };

    friend cVector3 operator+(const cVector3& v1, const cVector3& v2)
    {
        return cVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
    }

    friend cVector3 operator-(const cVector3& v1, const cVector3& v2)
    {
        return cVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
    }

    friend cVector3 operator*(const cVector3& v1, const cVector3& v2)
    {
        return cVector3(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
    }

    friend cVector3 operator*(const tFloat64 s, const cVector3& v)
    {
        return cVector3(v.x * s, v.y * s, v.z * s);
    }

    friend cVector3 operator*(const cVector3& v, const tFloat64 s)
    {
        return cVector3(v.x * s, v.y * s, v.z * s);
    }

    friend cVector3 operator/(const cVector3& v, const tFloat64 s)
    {
        return cVector3(v.x / s, v.y / s, v.z / s);
    }

    friend void operator+=(cVector3& v1, const cVector3& v2)
    {
        v1.x += v2.x;
        v1.y += v2.y;
        v1.z += v2.z;
    }

    friend void operator-=(cVector3& v1, const cVector3& v2)
    {
        v1.x -= v2.x;
        v1.y -= v2.y;
        v1.z -= v2.z;
    }

    friend bool operator==(const cVector3& v1, const cVector3& v2)
    {
        if (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z)
            return true;
        else
            return false;
    }

    friend bool operator!=(const cVector3& v1, const cVector3& v2)
    {
        if (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z)
            return false;
        else
            return true;
    }

    explicit operator IVector3*()
    {
        return static_cast<IVector3*>(this);
    }
};
 
inline const tFloat64 cVector3::nullScalar(0.0);
inline const tFloat64 cVector3::oneScalar(1.0);
inline const cVector3 cVector3::Null(nullScalar, nullScalar, nullScalar);
inline const cVector3 cVector3::One(oneScalar, oneScalar, oneScalar);
 
} // namespace dengar
 
using dengar::cVector3;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf