FMath/FMVector3.h

Go to the documentation of this file.

/*
    Copyright (C) 2005-2006 Feeling Software Inc.
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/

#ifndef _FM_VECTOR3_H_
#define _FM_VECTOR3_H_

class FCOLLADA_EXPORT FMVector3
{
public:
    float x;    
    float y;    
    float z;    
public:
    #ifndef _DEBUG
    FMVector3() {}
    #else
    FMVector3() { x = 123456789.0f; y = 123456789.0f; z = 123456789.0f; }
    #endif 

    FMVector3(float _x, float _y, float _z) { x = _x; y = _y; z = _z; }

    FMVector3(const float* source, uint32 startIndex = 0);

    inline float LengthSquared() const { return x * x + y * y + z * z; }

    inline float Length() const { return sqrtf(x * x + y * y + z * z); }

    inline void NormalizeIt() { float l = Length(); if (!IsEquivalent(l, 0.0f)) { x /= l; y /= l; z /= l; }}

    inline FMVector3 Normalize() const { float l = Length(); return FMVector3(x / l, y / l, z / l); }

    inline void Project(const FMVector3& unto) { (*this) = Projected(unto); }

    inline FMVector3 Projected(const FMVector3& unto);

    inline operator float*() { return &x; }

    inline operator const float*() const { return &x; }

    inline FMVector3& operator =(const float* v) { x = *v; y = *(v + 1); z = *(v + 2); return *this; }

    inline void ComponentMinimum(const FMVector3& min) { if (x < min.x) x = min.x; if (y < min.y) y = min.y; if (z < min.z) z = min.z; }

    inline void ComponentMaximum(const FMVector3& max) { if (x > max.x) x = max.x; if (y > max.y) y = max.y; if (z > max.z) z = max.z; }

    inline void ComponentClamp(const FMVector3& min, const FMVector3& max) { ComponentMinimum(min); ComponentMaximum(max); }

public:
    static const FMVector3 XAxis; 
    static const FMVector3 YAxis; 
    static const FMVector3 ZAxis; 
    static const FMVector3 Zero;  
    static const FMVector3 Origin;
};

inline FMVector3 operator +(const FMVector3& a, const FMVector3& b) { return FMVector3(a.x + b.x, a.y + b.y, a.z + b.z); }

inline FMVector3 operator -(const FMVector3& a, const FMVector3& b) { return FMVector3(a.x - b.x, a.y - b.y, a.z - b.z); }

inline FMVector3 operator +(const FMVector3& a) { return FMVector3(+a.x, +a.y, +a.z); }

inline FMVector3 operator -(const FMVector3& a) { return FMVector3(-a.x, -a.y, -a.z); }

inline float operator *(const FMVector3& a, const FMVector3& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }

inline FMVector3 operator *(const FMVector3& a, float b) { return FMVector3(a.x * b, a.y * b, a.z * b); }

inline FMVector3 operator *(float a, const FMVector3& b) { return FMVector3(a * b.x, a * b.y, a * b.z); }

inline FMVector3 operator ^(const FMVector3& a, const FMVector3& b) { return FMVector3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x); }

inline FMVector3& operator +=(FMVector3& b, const FMVector3& a) { b.x += a.x; b.y += a.y; b.z += a.z; return b; }

inline FMVector3& operator -=(FMVector3& b, const FMVector3& a) { b.x -= a.x; b.y -= a.y; b.z -= a.z; return b; }

inline FMVector3& operator *=(FMVector3& b, float a) { b.x *= a; b.y *= a; b.z *= a; return b; }

inline FMVector3& operator /=(FMVector3& b, float a) { b.x /= a; b.y /= a; b.z /= a; return b; }

inline bool IsEquivalent(const FMVector3& p, const FMVector3& q) { return IsEquivalent(p.x, q.x) && IsEquivalent(p.y, q.y) && IsEquivalent(p.z, q.z); }

inline bool operator == (const FMVector3& a, const FMVector3& b) { return IsEquivalent(a, b); }

// Already documented above.
inline FMVector3 FMVector3::Projected(const FMVector3& unto) { return ((*this) * unto) / unto.LengthSquared() * unto; }

typedef vector<FMVector3> FMVector3List;

#endif // _FM_VECTOR3_H_

---