Vector3.h

Go to the documentation of this file.

#ifndef G3D_Vector3_h
#define G3D_Vector3_h

#include "G3D/platform.h"
#include "G3D/g3dmath.h"
#include "G3D/Random.h"
#include "G3D/Vector2.h"
#include "G3D/Table.h"
#include "G3D/HashTrait.h"
#include "G3D/PositionTrait.h"
#include "G3D/Vector2.h"
#include <iostream>
#include <string>

namespace G3D {

class Vector2;
class Vector4;
class Vector4int8;
class Vector3int32;
class Any;

class Vector3 {
public:

 // coordinates
 float x, y, z;

private:

 // Hidden operators
 bool operator<(const Vector3&) const;
 bool operator>(const Vector3&) const;
 bool operator<=(const Vector3&) const;
 bool operator>=(const Vector3&) const;

public:
 Vector3();

 explicit Vector3(const Any& any);
 
 Any toAny(const std::string& name) const;

 Any toAny() const;

 Vector3(const Vector4int8&);
 Vector3(const class Vector2& v, float z);
 Vector3(const class Vector3int32& v);
 explicit Vector3(class BinaryInput& b);
 Vector3(float _x, float _y, float _z);
 explicit Vector3(float coordinate[3]);
 explicit Vector3(double coordinate[3]);
 Vector3(const class Vector3int16& v);
 explicit Vector3(class TextInput& t);
 explicit Vector3(const class Color3& c);

 void serialize(class BinaryOutput& b) const;
 void deserialize(class BinaryInput& b);

 void serialize(class TextOutput& t) const;
 void deserialize(class TextInput& t);

 // access vector V as V[0] = V.x, V[1] = V.y, V[2] = V.z
 //
 // WARNING. These member functions rely on
 // (1) Vector3 not having virtual functions
 // (2) the data packed in a 3*sizeof(float) memory block
 const float& __fastcall operator[] (int i) const;
 float& operator[] (int i);

 bool nonZero() const {
 return (x != 0) || (y != 0) || (z != 0); 
 }

 enum Axis {X_AXIS=0, Y_AXIS=1, Z_AXIS=2, DETECT_AXIS=-1};

 Axis primaryAxis() const;

 // assignment and comparison
 Vector3& __fastcall operator= (const Vector3& rkVector);
 Vector3& operator=(const Any& a);
 bool operator== (const Vector3& rkVector) const;
 bool operator!= (const Vector3& rkVector) const;
 size_t hashCode() const;
 bool fuzzyEq(const Vector3& other) const;
 bool fuzzyNe(const Vector3& other) const;

 bool isFinite() const;

 bool isNaN() const;

 bool isZero() const;

 bool isUnit() const;

 Vector3 movedTowards(const Vector3& goal, float maxTranslation) const;
 void moveTowards(const Vector3& goal, float maxTranslation);
 
 // arithmetic operations
 Vector3 __fastcall operator+ (const Vector3& v) const;
 Vector3 __fastcall operator- (const Vector3& v) const;
 Vector3 __fastcall operator* (float s) const;
 inline Vector3 __fastcall operator/ (float s) const {
 return *this * (1.0f / s);
 }
 Vector3 __fastcall operator* (const Vector3& v) const;
 Vector3 __fastcall operator/ (const Vector3& v) const;
 Vector3 __fastcall operator- () const;

 // arithmetic updates
 Vector3& __fastcall operator+= (const Vector3& v);
 Vector3& __fastcall operator-= (const Vector3& v);
 Vector3& __fastcall operator*= (float s);
 inline Vector3& __fastcall operator/= (float s) {
 return (*this *= (1.0f / s));
 }
 Vector3& __fastcall operator*= (const Vector3& v);
 Vector3& __fastcall operator/= (const Vector3& v);

 float length() const;

 float magnitude() const;

 Vector3 pow(float p) const {
 return Vector3(powf(x, p), powf(y, p), powf(z, p));
 }
 
 Vector3 direction() const;

 Vector3 fastDirection() const;

 Vector3 reflectAbout(const Vector3& normal) const;

 Vector3 reflectionDirection(const Vector3& normal) const;
 

 inline Vector3 directionOrZero() const {
 float mag = magnitude();
 if (mag < 0.0000001f) {
 return Vector3::zero();
 } else if (mag < 1.00001f && mag > 0.99999f) {
 return *this;
 } else {
 return *this * (1.0f / mag);
 }
 }

 Vector3 refractionDirection(
 const Vector3& normal,
 float iInside,
 float iOutside) const;

 inline Vector3 unit() const {
 return direction();
 }

 inline Vector3 fastUnit() const {
 return fastDirection();
 }

 float squaredLength() const;

 float squaredMagnitude () const;
 
 float __fastcall dot(const Vector3& rkVector) const;
 
 Vector3 __fastcall cross(const Vector3& rkVector) const;
 Vector3 unitCross(const Vector3& rkVector) const;

 class Matrix3 cross() const;

 Vector3 __fastcall min(const Vector3 &v) const;
 Vector3 __fastcall max(const Vector3 &v) const;

 inline float min() const {
 return G3D::min(G3D::min(x, y), z);
 }

 inline float max() const {
 return G3D::max(G3D::max(x, y), z);
 }

 std::string toString() const;

 inline Vector3 clamp(const Vector3& low, const Vector3& high) const {
 return Vector3(
 G3D::clamp(x, low.x, high.x),
 G3D::clamp(y, low.y, high.y),
 G3D::clamp(z, low.z, high.z));
 }

 inline Vector3 clamp(float low, float high) const {
 return Vector3(
 G3D::clamp(x, low, high),
 G3D::clamp(y, low, high),
 G3D::clamp(z, low, high));
 }


 inline Vector3 floor() const {
 return G3D::Vector3(::floor(x), ::floor(y), ::floor(z));
 }


 inline Vector3 round() const {
 return Vector3(G3D::round(x), G3D::round(y), G3D::round(z));
 }


 inline Vector3 lerp(const Vector3& v, float alpha) const {
 return (*this) + (v - *this) * alpha; 
 }

 static void orthonormalize (Vector3 akVector[3]);

 static Vector3 random(Random& r = Random::common());

 static Vector3 cosHemiRandom(const Vector3& n, Random& r = Random::common());

 static Vector3 cosSphereRandom(const Vector3& n, Random& r = Random::common());

 static Vector3 cosPowHemiRandom(const Vector3& n, const float k, Random& r = Random::common());

 static Vector3 hemiRandom(const Vector3& normal, Random& r = Random::common());

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

 inline float average() const {
 return sum() / 3.0f;
 }

 // Special values.
 static const Vector3& zero();
 static const Vector3& one();
 static const Vector3& unitX();
 static const Vector3& unitY();
 static const Vector3& unitZ();
 static const Vector3& inf();
 static const Vector3& nan();
 
 static const Vector3& minFinite();

 static const Vector3& maxFinite();


 inline void getTangents(Vector3& X, Vector3& Y) const {
 debugAssertM(G3D::fuzzyEq(length(), 1.0f), 
 "makeAxes requires Z to have unit length");
 
 // Choose another vector not perpendicular
 X = (abs(x) < 0.9f) ? Vector3::unitX() : Vector3::unitY();
 
 // Remove the part that is parallel to Z
 X -= *this * this->dot(X);
 X /= X.length();
 
 Y = this->cross(X);
 }


 // 2-char swizzles

 Vector2 xx() const;
 Vector2 yx() const;
 Vector2 zx() const;
 Vector2 xy() const;
 Vector2 yy() const;
 Vector2 zy() const;
 Vector2 xz() const;
 Vector2 yz() const;
 Vector2 zz() const;

 // 3-char swizzles

 Vector3 xxx() const;
 Vector3 yxx() const;
 Vector3 zxx() const;
 Vector3 xyx() const;
 Vector3 yyx() const;
 Vector3 zyx() const;
 Vector3 xzx() const;
 Vector3 yzx() const;
 Vector3 zzx() const;
 Vector3 xxy() const;
 Vector3 yxy() const;
 Vector3 zxy() const;
 Vector3 xyy() const;
 Vector3 yyy() const;
 Vector3 zyy() const;
 Vector3 xzy() const;
 Vector3 yzy() const;
 Vector3 zzy() const;
 Vector3 xxz() const;
 Vector3 yxz() const;
 Vector3 zxz() const;
 Vector3 xyz() const;
 Vector3 yyz() const;
 Vector3 zyz() const;
 Vector3 xzz() const;
 Vector3 yzz() const;
 Vector3 zzz() const;

 // 4-char swizzles

 Vector4 xxxx() const;
 Vector4 yxxx() const;
 Vector4 zxxx() const;
 Vector4 xyxx() const;
 Vector4 yyxx() const;
 Vector4 zyxx() const;
 Vector4 xzxx() const;
 Vector4 yzxx() const;
 Vector4 zzxx() const;
 Vector4 xxyx() const;
 Vector4 yxyx() const;
 Vector4 zxyx() const;
 Vector4 xyyx() const;
 Vector4 yyyx() const;
 Vector4 zyyx() const;
 Vector4 xzyx() const;
 Vector4 yzyx() const;
 Vector4 zzyx() const;
 Vector4 xxzx() const;
 Vector4 yxzx() const;
 Vector4 zxzx() const;
 Vector4 xyzx() const;
 Vector4 yyzx() const;
 Vector4 zyzx() const;
 Vector4 xzzx() const;
 Vector4 yzzx() const;
 Vector4 zzzx() const;
 Vector4 xxxy() const;
 Vector4 yxxy() const;
 Vector4 zxxy() const;
 Vector4 xyxy() const;
 Vector4 yyxy() const;
 Vector4 zyxy() const;
 Vector4 xzxy() const;
 Vector4 yzxy() const;
 Vector4 zzxy() const;
 Vector4 xxyy() const;
 Vector4 yxyy() const;
 Vector4 zxyy() const;
 Vector4 xyyy() const;
 Vector4 yyyy() const;
 Vector4 zyyy() const;
 Vector4 xzyy() const;
 Vector4 yzyy() const;
 Vector4 zzyy() const;
 Vector4 xxzy() const;
 Vector4 yxzy() const;
 Vector4 zxzy() const;
 Vector4 xyzy() const;
 Vector4 yyzy() const;
 Vector4 zyzy() const;
 Vector4 xzzy() const;
 Vector4 yzzy() const;
 Vector4 zzzy() const;
 Vector4 xxxz() const;
 Vector4 yxxz() const;
 Vector4 zxxz() const;
 Vector4 xyxz() const;
 Vector4 yyxz() const;
 Vector4 zyxz() const;
 Vector4 xzxz() const;
 Vector4 yzxz() const;
 Vector4 zzxz() const;
 Vector4 xxyz() const;
 Vector4 yxyz() const;
 Vector4 zxyz() const;
 Vector4 xyyz() const;
 Vector4 yyyz() const;
 Vector4 zyyz() const;
 Vector4 xzyz() const;
 Vector4 yzyz() const;
 Vector4 zzyz() const;
 Vector4 xxzz() const;
 Vector4 yxzz() const;
 Vector4 zxzz() const;
 Vector4 xyzz() const;
 Vector4 yyzz() const;
 Vector4 zyzz() const;
 Vector4 xzzz() const;
 Vector4 yzzz() const;
 Vector4 zzzz() const;

 static Vector3& ignore();
};



inline G3D::Vector3 operator*(float s, const G3D::Vector3& v) {
 return v * s;
}

inline G3D::Vector3 operator*(double s, const G3D::Vector3& v) {
 return v * (float)s;
}

inline G3D::Vector3 operator*(int s, const G3D::Vector3& v) {
 return v * (float)s;
}

std::ostream& operator<<(std::ostream& os, const Vector3&);


void serialize(const Vector3::Axis& a, class BinaryOutput& bo);
void deserialize(Vector3::Axis& a, class BinaryInput& bo);


//----------------------------------------------------------------------------
inline Vector3::Vector3() : x(0.0f), y(0.0f), z(0.0f) {
}

//----------------------------------------------------------------------------

inline Vector3::Vector3 (float fX, float fY, float fZ) : x(fX), y(fY), z(fZ) {
}

//----------------------------------------------------------------------------
inline Vector3::Vector3 (float V[3]) : x(V[0]), y(V[1]), z(V[2]){
}

//----------------------------------------------------------------------------
inline Vector3::Vector3 (double V[3]) : x((float)V[0]), y((float)V[1]), z((float)V[2]){
}

//----------------------------------------------------------------------------
inline const float& Vector3::operator[] (int i) const {
 return ((float*)this)[i];
}

inline float& Vector3::operator[] (int i) {
 return ((float*)this)[i];
}


//----------------------------------------------------------------------------
inline Vector3& Vector3::operator= (const Vector3& rkVector) {
 x = rkVector.x;
 y = rkVector.y;
 z = rkVector.z;
 return *this;
}

//----------------------------------------------------------------------------

inline bool Vector3::fuzzyEq(const Vector3& other) const {
 return G3D::fuzzyEq((*this - other).squaredMagnitude(), 0);
}

//----------------------------------------------------------------------------

inline bool Vector3::fuzzyNe(const Vector3& other) const {
 return G3D::fuzzyNe((*this - other).squaredMagnitude(), 0);
}

//----------------------------------------------------------------------------

inline bool Vector3::isFinite() const {
 return G3D::isFinite(x) && G3D::isFinite(y) && G3D::isFinite(z);
}

//----------------------------------------------------------------------------
inline bool Vector3::operator== (const Vector3& rkVector) const {
 return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
}

//----------------------------------------------------------------------------
inline bool Vector3::operator!= (const Vector3& rkVector) const {
 return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::operator+ (const Vector3& rkVector) const {
 return Vector3(x + rkVector.x, y + rkVector.y, z + rkVector.z);
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::operator- (const Vector3& rkVector) const {
 return Vector3(x - rkVector.x, y - rkVector.y, z - rkVector.z);
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::operator* (const Vector3& rkVector) const {
 return Vector3(x * rkVector.x, y * rkVector.y, z * rkVector.z);
}

inline Vector3 Vector3::operator*(float f) const {
 return Vector3(x * f, y * f, z * f);
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::operator/ (const Vector3& rkVector) const {
 return Vector3(x / rkVector.x, y / rkVector.y, z / rkVector.z);
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::operator- () const {
 return Vector3(-x, -y, -z);
}

//----------------------------------------------------------------------------
inline Vector3& Vector3::operator+= (const Vector3& rkVector) {
 x += rkVector.x;
 y += rkVector.y;
 z += rkVector.z;
 return *this;
}

//----------------------------------------------------------------------------
inline Vector3& Vector3::operator-= (const Vector3& rkVector) {
 x -= rkVector.x;
 y -= rkVector.y;
 z -= rkVector.z;
 return *this;
}

//----------------------------------------------------------------------------
inline Vector3& Vector3::operator*= (float fScalar) {
 x *= fScalar;
 y *= fScalar;
 z *= fScalar;
 return *this;
}

//----------------------------------------------------------------------------
inline Vector3& Vector3::operator*= (const Vector3& rkVector) {
 x *= rkVector.x;
 y *= rkVector.y;
 z *= rkVector.z;
 return *this;
}

//----------------------------------------------------------------------------
inline Vector3& Vector3::operator/= (const Vector3& rkVector) {
 x /= rkVector.x;
 y /= rkVector.y;
 z /= rkVector.z;
 return *this;
}

//----------------------------------------------------------------------------
inline float Vector3::squaredMagnitude () const {
 return x*x + y*y + z*z;
}

//----------------------------------------------------------------------------
inline float Vector3::squaredLength () const {
 return squaredMagnitude();
}

//----------------------------------------------------------------------------
inline float Vector3::magnitude() const {
 return ::sqrtf(x*x + y*y + z*z);
}

//----------------------------------------------------------------------------
inline float Vector3::length() const {
 return magnitude();
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::direction () const {
 const float lenSquared = squaredMagnitude();
 const float invSqrt = 1.0f / sqrtf(lenSquared);
 return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
}

//----------------------------------------------------------------------------

inline Vector3 Vector3::fastDirection () const {
 float lenSquared = x * x + y * y + z * z;
 float invSqrt = rsq(lenSquared);
 return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
}

//----------------------------------------------------------------------------
inline float Vector3::dot (const Vector3& rkVector) const {
 return x*rkVector.x + y*rkVector.y + z*rkVector.z;
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::cross (const Vector3& rkVector) const {
 return Vector3(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
 x*rkVector.y - y*rkVector.x);
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::unitCross (const Vector3& rkVector) const {
 Vector3 kCross(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
 x*rkVector.y - y*rkVector.x);
 return kCross.direction();
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::min(const Vector3 &v) const {
 return Vector3(G3D::min(v.x, x), G3D::min(v.y, y), G3D::min(v.z, z));
}

//----------------------------------------------------------------------------
inline Vector3 Vector3::max(const Vector3 &v) const {
 return Vector3(G3D::max(v.x, x), G3D::max(v.y, y), G3D::max(v.z, z));
}

//----------------------------------------------------------------------------
inline bool Vector3::isZero() const {
 return G3D::fuzzyEq(fabsf(x) + fabsf(y) + fabsf(z), 0.0f);
}

//----------------------------------------------------------------------------

inline bool Vector3::isUnit() const {
 return G3D::fuzzyEq(squaredMagnitude(), 1.0f);
}

typedef Vector3 Point3;

void serialize(const Vector3& v, class BinaryOutput& b);
void deserialize(Vector3& v, class BinaryInput& b);

} // namespace G3D


template <>
struct HashTrait<G3D::Vector3> {
 static size_t hashCode(const G3D::Vector3& key) {
 return key.hashCode();
 }
};


template<> struct PositionTrait<class G3D::Vector2> {
 static void getPosition(const G3D::Vector2& v, G3D::Vector3& p) { p = G3D::Vector3(v, 0); }
};

template<> struct PositionTrait<class G3D::Vector3> {
 static void getPosition(const G3D::Vector3& v, G3D::Vector3& p) { p = v; }
};


#endif