D:/Uni/8.Semester/InfoVis/Demo/source/Util/Vector3.h

#ifndef __VECTOR3_H__
#define __VECTOR3_H__

class Vector3
{
public:
    Vector3() : x(0), y(0), z(0) {};

    Vector3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) { };
    Vector3(const Vector3& other) : x(other.x), y(other.y), z(other.z) { };

        const Vector3& operator=(const Vector3& other);

        bool operator!=(const Vector3& other) const { return ((x != other.x) || (y != other.y) || (z != other.z)); }
    bool operator==(const Vector3& other) const { return ((x == other.x) && (y == other.y) && (z == other.z)); }
        bool operator<(const Vector3& other) const      { return x < other.x; }

    Vector3 operator-() const { return Vector3(-x, -y, -z); }
           
    Vector3 operator+(const Vector3& other) const { return Vector3(x + other.x, y + other.y, z + other.z); }
    const Vector3& operator+=(const Vector3& other) { x += other.x; y += other.y; z += other.z; return (*this); }    

    Vector3 operator-(const Vector3& other) const { return Vector3(x - other.x, y - other.y, z - other.z); }
    const Vector3& operator-=(const Vector3& other) { x -= other.x; y -= other.y; z -= other.z; return (*this); }

    Vector3 operator*(const Vector3& other) const { return Vector3(x * other.x, y * other.y, z * other.z); }
    const Vector3& operator*=(const Vector3& other) { x *= other.x; y *= other.y; z *= other.z; return (*this); }

    Vector3 operator*(float scalar) const { return Vector3(x * scalar, y * scalar, z * scalar); }
    const Vector3& operator*=(float scalar) { x *= scalar; y *= scalar; z *= scalar; return (*this); }    

        Vector3 operator/(const Vector3& other) const;
        const Vector3& operator/=(const Vector3& other);

        Vector3 operator/(float scalar) const;
        const Vector3& operator/=(float scalar);


    void Set(float _x, float _y, float _z) { x = _x; y = _y; z = _z; }
    float Length() const;
        float SquaredLength() const { return (x * x + y * y + z * z); }

        Vector3& RotateX(float d);
        Vector3& RotateY(float d);
        Vector3& RotateZ(float d);
        Vector3& RotateAbout(const Vector3& v, float d);

    float DotProduct(const Vector3& other) const { return (x * other.x + y * other.y + z * other.z); }
        void Normalize();            

        float Unitize(float tolerance = 1e-06f );

        Vector3 CrossProduct(const Vector3& other) const { return Vector3(y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x); }
        Vector3 UnitCrossProduct(const Vector3& other) const;

        static void GenerateOrthonormalBasis(Vector3& u, Vector3& v, Vector3& w);

        int GetMajorAxis(void) const;

        Vector3 CalcPerpendicularVector(void) const;

        void Interpolate(const Vector3& v0, const Vector3& v1, float t);

        bool Equals(const Vector3 &v, float epsilon = 1e-3f) const;

public:
        union
        {
                struct
                {
                        float  x;
                        float  y;
                        float  z;
                };

                struct
                {
                        float  comp[3];
                };
        };

        static float Distance(const Vector3& v0, const Vector3& v1);

        static float SquaredDistance(const Vector3& v0, const Vector3& v1)
        {
                return ((v0.x-v1.x) * (v0.x-v1.x) + (v0.y-v1.y) * (v0.y-v1.y) + (v0.z-v1.z) * (v0.z-v1.z));
        }

        static Vector3 RandomVector(void);

        static const Vector3 ZERO;
        static const Vector3 ONE;
        static const Vector3 X_AXIS;
        static const Vector3 Y_AXIS;
        static const Vector3 Z_AXIS;
};

#endif //__VECTOR3_H__

---