kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP organization of library

Browse Source
This commit is contained in:
Kearwood Kip Gilbert
2017-07-29 01:39:41 -07:00
parent a4bc7267d3
commit 1d98f314b2
8 changed files with 305 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
kraken/public/KRAABB.h
View File

@@ -22,58 +22,58 @@ class KRMat4;
class KRAABB { class KRAABB {
public: public:
KRAABB(const Vector3 &minPoint, const Vector3 &maxPoint); KRAABB(const Vector3 &minPoint, const Vector3 &maxPoint);
KRAABB(const Vector3 &corner1, const Vector3 &corner2, const KRMat4 &modelMatrix); KRAABB(const Vector3 &corner1, const Vector3 &corner2, const KRMat4 &modelMatrix);
KRAABB(); KRAABB();
~KRAABB(); ~KRAABB();
void scale(const Vector3 &s); void scale(const Vector3 &s);
void scale(float s); void scale(float s);
Vector3 center() const; Vector3 center() const;
Vector3 size() const; Vector3 size() const;
float volume() const; float volume() const;
bool intersects(const KRAABB& b) const; bool intersects(const KRAABB& b) const;
bool contains(const KRAABB &b) const; bool contains(const KRAABB &b) const;
bool contains(const Vector3 &v) const; bool contains(const Vector3 &v) const;
bool intersectsLine(const Vector3 &v1, const Vector3 &v2) const; bool intersectsLine(const Vector3 &v1, const Vector3 &v2) const;
bool intersectsRay(const Vector3 &v1, const Vector3 &dir) const; bool intersectsRay(const Vector3 &v1, const Vector3 &dir) const;
bool intersectsSphere(const Vector3 &center, float radius) const; bool intersectsSphere(const Vector3 &center, float radius) const;
void encapsulate(const KRAABB & b); void encapsulate(const KRAABB & b);
KRAABB& operator =(const KRAABB& b); KRAABB& operator =(const KRAABB& b);
bool operator ==(const KRAABB& b) const; bool operator ==(const KRAABB& b) const;
bool operator !=(const KRAABB& b) const; bool operator !=(const KRAABB& b) const;
// Comparison operators are implemented to allow insertion into sorted containers such as std::set // Comparison operators are implemented to allow insertion into sorted containers such as std::set
bool operator >(const KRAABB& b) const; bool operator >(const KRAABB& b) const;
bool operator <(const KRAABB& b) const; bool operator <(const KRAABB& b) const;
Vector3 min; Vector3 min;
Vector3 max; Vector3 max;
static KRAABB Infinite(); static KRAABB Infinite();
static KRAABB Zero(); static KRAABB Zero();
float longest_radius() const; float longest_radius() const;
Vector3 nearestPoint(const Vector3 & v) const; Vector3 nearestPoint(const Vector3 & v) const;
}; };
} // namespace kraken } // namespace kraken
namespace std { namespace std {
template<> template<>
struct hash<kraken::KRAABB> { struct hash<kraken::KRAABB> {
public: public:
size_t operator()(const kraken::KRAABB &s) const size_t operator()(const kraken::KRAABB &s) const
{ {
size_t h1 = hash<kraken::Vector3>()(s.min); size_t h1 = hash<kraken::Vector3>()(s.min);
size_t h2 = hash<kraken::Vector3>()(s.max); size_t h2 = hash<kraken::Vector3>()(s.max);
return h1 ^ ( h2 << 1 ); return h1 ^ ( h2 << 1 );
} }
}; };
} } // namespace std
#endif /* defined(KRAABB_H) */ #endif /* defined(KRAABB_H) */

102
kraken/public/KRMat4.h
View File

@@ -33,83 +33,83 @@
#include "Vector3.h" #include "Vector3.h"
#include "Vector4.h" #include "Vector4.h"
#ifndef KRMAT4_H #ifndef KRAKEN_MATRIX4_H
#define KRMAT4_H #define KRAKEN_MATRIX4_H
namespace kraken { namespace kraken {
typedef enum { typedef enum {
X_AXIS, X_AXIS,
Y_AXIS, Y_AXIS,
Z_AXIS Z_AXIS
} AXIS; } AXIS;
class KRQuaternion; class KRQuaternion;
class KRMat4 { class KRMat4 {
public: public:
float c[16]; // Matrix components, in column-major order float c[16]; // Matrix components, in column-major order
// Default constructor - Creates an identity matrix // Default constructor - Creates an identity matrix
KRMat4(); KRMat4();
KRMat4(float *pMat); KRMat4(float *pMat);
KRMat4(const Vector3 &axis_x, const Vector3 &axis_y, const Vector3 &axis_z, const Vector3 &trans); KRMat4(const Vector3 &axis_x, const Vector3 &axis_y, const Vector3 &axis_z, const Vector3 &trans);
// Destructor // Destructor
~KRMat4(); ~KRMat4();
// Copy constructor // Copy constructor
KRMat4(const KRMat4 &m); KRMat4(const KRMat4 &m);
// Overload assignment operator // Overload assignment operator
KRMat4& operator=(const KRMat4 &m); KRMat4& operator=(const KRMat4 &m);
// Overload comparison operator // Overload comparison operator
bool operator==(const KRMat4 &m) const; bool operator==(const KRMat4 &m) const;
// Overload compound multiply operator // Overload compound multiply operator
KRMat4& operator*=(const KRMat4 &m); KRMat4& operator*=(const KRMat4 &m);
float& operator[](unsigned i); float& operator[](unsigned i);
float operator[](unsigned i) const; float operator[](unsigned i) const;
// Overload multiply operator // Overload multiply operator
//KRMat4& operator*(const KRMat4 &m); //KRMat4& operator*(const KRMat4 &m);
KRMat4 operator*(const KRMat4 &m) const; KRMat4 operator*(const KRMat4 &m) const;
float *getPointer(); float *getPointer();
void perspective(float fov, float aspect, float nearz, float farz); void perspective(float fov, float aspect, float nearz, float farz);
void ortho(float left, float right, float top, float bottom, float nearz, float farz); void ortho(float left, float right, float top, float bottom, float nearz, float farz);
void translate(float x, float y, float z); void translate(float x, float y, float z);
void translate(const Vector3 &v); void translate(const Vector3 &v);
void scale(float x, float y, float z); void scale(float x, float y, float z);
void scale(const Vector3 &v); void scale(const Vector3 &v);
void scale(float s); void scale(float s);
void rotate(float angle, AXIS axis); void rotate(float angle, AXIS axis);
void rotate(const KRQuaternion &q); void rotate(const KRQuaternion &q);
void bias(); void bias();
bool invert(); bool invert();
void transpose(); void transpose();
static Vector3 DotNoTranslate(const KRMat4 &m, const Vector3 &v); // Dot product without including translation; useful for transforming normals and tangents static Vector3 DotNoTranslate(const KRMat4 &m, const Vector3 &v); // Dot product without including translation; useful for transforming normals and tangents
static KRMat4 Invert(const KRMat4 &m); static KRMat4 Invert(const KRMat4 &m);
static KRMat4 Transpose(const KRMat4 &m); static KRMat4 Transpose(const KRMat4 &m);
static Vector3 Dot(const KRMat4 &m, const Vector3 &v); static Vector3 Dot(const KRMat4 &m, const Vector3 &v);
static Vector4 Dot4(const KRMat4 &m, const Vector4 &v); static Vector4 Dot4(const KRMat4 &m, const Vector4 &v);
static float DotW(const KRMat4 &m, const Vector3 &v); static float DotW(const KRMat4 &m, const Vector3 &v);
static Vector3 DotWDiv(const KRMat4 &m, const Vector3 &v); static Vector3 DotWDiv(const KRMat4 &m, const Vector3 &v);
static KRMat4 LookAt(const Vector3 &cameraPos, const Vector3 &lookAtPos, const Vector3 &upDirection); static KRMat4 LookAt(const Vector3 &cameraPos, const Vector3 &lookAtPos, const Vector3 &upDirection);
static KRMat4 Translation(const Vector3 &v); static KRMat4 Translation(const Vector3 &v);
static KRMat4 Rotation(const Vector3 &v); static KRMat4 Rotation(const Vector3 &v);
static KRMat4 Scaling(const Vector3 &v); static KRMat4 Scaling(const Vector3 &v);
}; };
} // namespace kraken } // namespace kraken
#endif // KRMAT4_H #endif // KRAKEN_MATRIX4_H

72
kraken/public/KRQuaternion.h
View File

@@ -38,51 +38,51 @@ namespace kraken {
class KRQuaternion { class KRQuaternion {
public: public:
KRQuaternion(); KRQuaternion();
KRQuaternion(float w, float x, float y, float z); KRQuaternion(float w, float x, float y, float z);
KRQuaternion(const KRQuaternion& p); KRQuaternion(const KRQuaternion& p);
KRQuaternion(const Vector3 &euler); KRQuaternion(const Vector3 &euler);
KRQuaternion(const Vector3 &from_vector, const Vector3 &to_vector); KRQuaternion(const Vector3 &from_vector, const Vector3 &to_vector);
~KRQuaternion(); ~KRQuaternion();
KRQuaternion& operator =( const KRQuaternion& p ); KRQuaternion& operator =( const KRQuaternion& p );
KRQuaternion operator +(const KRQuaternion &v) const; KRQuaternion operator +(const KRQuaternion &v) const;
KRQuaternion operator -(const KRQuaternion &v) const; KRQuaternion operator -(const KRQuaternion &v) const;
KRQuaternion operator +() const; KRQuaternion operator +() const;
KRQuaternion operator -() const; KRQuaternion operator -() const;
KRQuaternion operator *(const KRQuaternion &v); KRQuaternion operator *(const KRQuaternion &v);
KRQuaternion operator *(float num) const; KRQuaternion operator *(float num) const;
KRQuaternion operator /(float num) const; KRQuaternion operator /(float num) const;
KRQuaternion& operator +=(const KRQuaternion& v); KRQuaternion& operator +=(const KRQuaternion& v);
KRQuaternion& operator -=(const KRQuaternion& v); KRQuaternion& operator -=(const KRQuaternion& v);
KRQuaternion& operator *=(const KRQuaternion& v); KRQuaternion& operator *=(const KRQuaternion& v);
KRQuaternion& operator *=(const float& v); KRQuaternion& operator *=(const float& v);
KRQuaternion& operator /=(const float& v); KRQuaternion& operator /=(const float& v);
friend bool operator ==(KRQuaternion &v1, KRQuaternion &v2); friend bool operator ==(KRQuaternion &v1, KRQuaternion &v2);
friend bool operator !=(KRQuaternion &v1, KRQuaternion &v2); friend bool operator !=(KRQuaternion &v1, KRQuaternion &v2);
float& operator [](unsigned i); float& operator [](unsigned i);
float operator [](unsigned i) const; float operator [](unsigned i) const;
void setEulerXYZ(const Vector3 &euler); void setEulerXYZ(const Vector3 &euler);
void setEulerZYX(const Vector3 &euler); void setEulerZYX(const Vector3 &euler);
Vector3 eulerXYZ() const; Vector3 eulerXYZ() const;
KRMat4 rotationMatrix() const; KRMat4 rotationMatrix() const;
void normalize(); void normalize();
static KRQuaternion Normalize(const KRQuaternion &v1); static KRQuaternion Normalize(const KRQuaternion &v1);
void conjugate(); void conjugate();
static KRQuaternion Conjugate(const KRQuaternion &v1); static KRQuaternion Conjugate(const KRQuaternion &v1);
static KRQuaternion FromAngleAxis(const Vector3 &axis, float angle); static KRQuaternion FromAngleAxis(const Vector3 &axis, float angle);
static KRQuaternion Lerp(const KRQuaternion &a, const KRQuaternion &b, float t); static KRQuaternion Lerp(const KRQuaternion &a, const KRQuaternion &b, float t);
static KRQuaternion Slerp(const KRQuaternion &a, const KRQuaternion &b, float t); static KRQuaternion Slerp(const KRQuaternion &a, const KRQuaternion &b, float t);
static float Dot(const KRQuaternion &v1, const KRQuaternion &v2); static float Dot(const KRQuaternion &v1, const KRQuaternion &v2);
private: private:
float m_val[4]; float m_val[4];
}; };
} // namespace kraken } // namespace kraken

28
kraken/public/KRTriangle3.h
View File

@@ -39,25 +39,25 @@ namespace kraken {
class KRTriangle3 class KRTriangle3
{ {
public: public:
Vector3 vert[3]; Vector3 vert[3];
KRTriangle3(const KRTriangle3 &tri); KRTriangle3(const KRTriangle3 &tri);
KRTriangle3(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3); KRTriangle3(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3);
~KRTriangle3(); ~KRTriangle3();
Vector3 calculateNormal() const; Vector3 calculateNormal() const;
bool operator ==(const KRTriangle3& b) const; bool operator ==(const KRTriangle3& b) const;
bool operator !=(const KRTriangle3& b) const; bool operator !=(const KRTriangle3& b) const;
KRTriangle3& operator =(const KRTriangle3& b); KRTriangle3& operator =(const KRTriangle3& b);
Vector3& operator[](unsigned int i); Vector3& operator[](unsigned int i);
Vector3 operator[](unsigned int i) const; Vector3 operator[](unsigned int i) const;
bool rayCast(const Vector3 &start, const Vector3 &dir, Vector3 &hit_point) const; bool rayCast(const Vector3 &start, const Vector3 &dir, Vector3 &hit_point) const;
bool sphereCast(const Vector3 &start, const Vector3 &dir, float radius, Vector3 &hit_point, float &hit_distance) const; bool sphereCast(const Vector3 &start, const Vector3 &dir, float radius, Vector3 &hit_point, float &hit_distance) const;
bool containsPoint(const Vector3 &p) const; bool containsPoint(const Vector3 &p) const;
Vector3 closestPointOnTriangle(const Vector3 &p) const; Vector3 closestPointOnTriangle(const Vector3 &p) const;
}; };
} // namespace kraken } // namespace kraken

2
kraken/public/scalar.h
View File

@@ -34,7 +34,7 @@
namespace kraken { namespace kraken {
float SmoothStep(float a, float b, float t); float SmoothStep(float a, float b, float t);
}; // namespace kraken }; // namespace kraken

89
kraken/public/vector2.h
View File

@@ -39,62 +39,62 @@ namespace kraken {
class Vector2 { class Vector2 {
public: public:
union { union {
struct { struct {
float x, y; float x, y;
};
float c[2];
}; };
float c[2];
};
Vector2(); Vector2();
Vector2(float X, float Y); Vector2(float X, float Y);
Vector2(float v); Vector2(float v);
Vector2(float *v); Vector2(float *v);
Vector2(const Vector2 &v); Vector2(const Vector2 &v);
~Vector2(); ~Vector2();
// Vector2 swizzle getters // Vector2 swizzle getters
Vector2 yx() const; Vector2 yx() const;
// Vector2 swizzle setters // Vector2 swizzle setters
void yx(const Vector2 &v); void yx(const Vector2 &v);
Vector2& operator =(const Vector2& b); Vector2& operator =(const Vector2& b);
Vector2 operator +(const Vector2& b) const; Vector2 operator +(const Vector2& b) const;
Vector2 operator -(const Vector2& b) const; Vector2 operator -(const Vector2& b) const;
Vector2 operator +() const; Vector2 operator +() const;
Vector2 operator -() const; Vector2 operator -() const;
Vector2 operator *(const float v) const; Vector2 operator *(const float v) const;
Vector2 operator /(const float v) const; Vector2 operator /(const float v) const;
Vector2& operator +=(const Vector2& b); Vector2& operator +=(const Vector2& b);
Vector2& operator -=(const Vector2& b); Vector2& operator -=(const Vector2& b);
Vector2& operator *=(const float v); Vector2& operator *=(const float v);
Vector2& operator /=(const float v); Vector2& operator /=(const float v);
// Comparison operators are implemented to allow insertion into sorted containers such as std::set // Comparison operators are implemented to allow insertion into sorted containers such as std::set
bool operator >(const Vector2& b) const; bool operator >(const Vector2& b) const;
bool operator <(const Vector2& b) const; bool operator <(const Vector2& b) const;
bool operator ==(const Vector2& b) const; bool operator ==(const Vector2& b) const;
bool operator !=(const Vector2& b) const; bool operator !=(const Vector2& b) const;
float& operator[](unsigned i); float& operator[](unsigned i);
float operator[](unsigned i) const; float operator[](unsigned i) const;
float sqrMagnitude() const; float sqrMagnitude() const;
float magnitude() const; float magnitude() const;
void normalize(); void normalize();
static Vector2 Normalize(const Vector2 &v); static Vector2 Normalize(const Vector2 &v);
static float Cross(const Vector2 &v1, const Vector2 &v2); static float Cross(const Vector2 &v1, const Vector2 &v2);
static float Dot(const Vector2 &v1, const Vector2 &v2); static float Dot(const Vector2 &v1, const Vector2 &v2);
static Vector2 Min(); static Vector2 Min();
static Vector2 Max(); static Vector2 Max();
static Vector2 Zero(); static Vector2 Zero();
static Vector2 One(); static Vector2 One();
}; };
} // namespace kraken } // namespace kraken
@@ -110,7 +110,6 @@ namespace std {
return h1 ^ (h2 << 1); return h1 ^ (h2 << 1);
} }
}; };
} } // namespace std
#endif // KRAKEN_VECTOR2_H #endif // KRAKEN_VECTOR2_H

142
kraken/public/vector3.h
View File

@@ -42,89 +42,89 @@ namespace kraken {
class Vector3 { class Vector3 {
public: public:
union { union {
struct { struct {
float x, y, z; float x, y, z;
};
float c[3];
}; };
float c[3];
};
Vector3(); Vector3();
Vector3(float X, float Y, float Z); Vector3(float X, float Y, float Z);
Vector3(float v); Vector3(float v);
Vector3(float *v); Vector3(float *v);
Vector3(double *v); Vector3(double *v);
Vector3(const Vector3 &v); Vector3(const Vector3 &v);
Vector3(const Vector4 &v); Vector3(const Vector4 &v);
~Vector3(); ~Vector3();
// Vector2 swizzle getters // Vector2 swizzle getters
Vector2 xx() const; Vector2 xx() const;
Vector2 xy() const; Vector2 xy() const;
Vector2 xz() const; Vector2 xz() const;
Vector2 yx() const; Vector2 yx() const;
Vector2 yy() const; Vector2 yy() const;
Vector2 yz() const; Vector2 yz() const;
Vector2 zx() const; Vector2 zx() const;
Vector2 zy() const; Vector2 zy() const;
Vector2 zz() const; Vector2 zz() const;
// Vector2 swizzle setters // Vector2 swizzle setters
void xy(const Vector2 &v); void xy(const Vector2 &v);
void xz(const Vector2 &v); void xz(const Vector2 &v);
void yx(const Vector2 &v); void yx(const Vector2 &v);
void yz(const Vector2 &v); void yz(const Vector2 &v);
void zx(const Vector2 &v); void zx(const Vector2 &v);
void zy(const Vector2 &v); void zy(const Vector2 &v);
Vector3& operator =(const Vector3& b); Vector3& operator =(const Vector3& b);
Vector3& operator =(const Vector4& b); Vector3& operator =(const Vector4& b);
Vector3 operator +(const Vector3& b) const; Vector3 operator +(const Vector3& b) const;
Vector3 operator -(const Vector3& b) const; Vector3 operator -(const Vector3& b) const;
Vector3 operator +() const; Vector3 operator +() const;
Vector3 operator -() const; Vector3 operator -() const;
Vector3 operator *(const float v) const; Vector3 operator *(const float v) const;
Vector3 operator /(const float v) const; Vector3 operator /(const float v) const;
Vector3& operator +=(const Vector3& b); Vector3& operator +=(const Vector3& b);
Vector3& operator -=(const Vector3& b); Vector3& operator -=(const Vector3& b);
Vector3& operator *=(const float v); Vector3& operator *=(const float v);
Vector3& operator /=(const float v); Vector3& operator /=(const float v);
bool operator ==(const Vector3& b) const; bool operator ==(const Vector3& b) const;
bool operator !=(const Vector3& b) const; bool operator !=(const Vector3& b) const;
// Comparison operators are implemented to allow insertion into sorted containers such as std::set // Comparison operators are implemented to allow insertion into sorted containers such as std::set
bool operator >(const Vector3& b) const; bool operator >(const Vector3& b) const;
bool operator <(const Vector3& b) const; bool operator <(const Vector3& b) const;
float& operator[](unsigned i); float& operator[](unsigned i);
float operator[](unsigned i) const; float operator[](unsigned i) const;
float sqrMagnitude() const; // calculate the square of the magnitude (useful for comparison of magnitudes without the cost of a sqrt() function) float sqrMagnitude() const; // calculate the square of the magnitude (useful for comparison of magnitudes without the cost of a sqrt() function)
float magnitude() const; float magnitude() const;
void scale(const Vector3 &v); void scale(const Vector3 &v);
void normalize(); void normalize();
static Vector3 Normalize(const Vector3 &v); static Vector3 Normalize(const Vector3 &v);
static Vector3 Cross(const Vector3 &v1, const Vector3 &v2); static Vector3 Cross(const Vector3 &v1, const Vector3 &v2);
static float Dot(const Vector3 &v1, const Vector3 &v2); static float Dot(const Vector3 &v1, const Vector3 &v2);
static Vector3 Min(); static Vector3 Min();
static Vector3 Max(); static Vector3 Max();
static const Vector3 &Zero(); static const Vector3 &Zero();
static Vector3 One(); static Vector3 One();
static Vector3 Forward(); static Vector3 Forward();
static Vector3 Backward(); static Vector3 Backward();
static Vector3 Up(); static Vector3 Up();
static Vector3 Down(); static Vector3 Down();
static Vector3 Left(); static Vector3 Left();
static Vector3 Right(); static Vector3 Right();
static Vector3 Scale(const Vector3 &v1, const Vector3 &v2); static Vector3 Scale(const Vector3 &v1, const Vector3 &v2);
static Vector3 Lerp(const Vector3 &v1, const Vector3 &v2, float d); static Vector3 Lerp(const Vector3 &v1, const Vector3 &v2, float d);
static Vector3 Slerp(const Vector3 &v1, const Vector3 &v2, float d); static Vector3 Slerp(const Vector3 &v1, const Vector3 &v2, float d);
static void OrthoNormalize(Vector3 &normal, Vector3 &tangent); // Gram-Schmidt Orthonormalization static void OrthoNormalize(Vector3 &normal, Vector3 &tangent); // Gram-Schmidt Orthonormalization
}; };
} // namespace kraken } // namespace kraken
@@ -141,6 +141,6 @@ namespace std {
return h1 ^ (h2 << 1) ^ (h3 << 2); return h1 ^ (h2 << 1) ^ (h3 << 2);
} }
}; };
} } // namespace std
#endif // KRAKEN_VECTOR3_H #endif // KRAKEN_VECTOR3_H

98
kraken/public/vector4.h
View File

@@ -41,65 +41,65 @@ class Vector3;
class Vector4 { class Vector4 {
public: public:
union { union {
struct { struct {
float x, y, z, w; float x, y, z, w;
};
float c[4];
}; };
float c[4];
};
Vector4(); Vector4();
Vector4(float X, float Y, float Z, float W); Vector4(float X, float Y, float Z, float W);
Vector4(float v); Vector4(float v);
Vector4(float *v); Vector4(float *v);
Vector4(const Vector4 &v); Vector4(const Vector4 &v);
Vector4(const Vector3 &v, float W); Vector4(const Vector3 &v, float W);
~Vector4(); ~Vector4();
Vector4& operator =(const Vector4& b); Vector4& operator =(const Vector4& b);
Vector4 operator +(const Vector4& b) const; Vector4 operator +(const Vector4& b) const;
Vector4 operator -(const Vector4& b) const; Vector4 operator -(const Vector4& b) const;
Vector4 operator +() const; Vector4 operator +() const;
Vector4 operator -() const; Vector4 operator -() const;
Vector4 operator *(const float v) const; Vector4 operator *(const float v) const;
Vector4 operator /(const float v) const; Vector4 operator /(const float v) const;
Vector4& operator +=(const Vector4& b); Vector4& operator +=(const Vector4& b);
Vector4& operator -=(const Vector4& b); Vector4& operator -=(const Vector4& b);
Vector4& operator *=(const float v); Vector4& operator *=(const float v);
Vector4& operator /=(const float v); Vector4& operator /=(const float v);
bool operator ==(const Vector4& b) const; bool operator ==(const Vector4& b) const;
bool operator !=(const Vector4& b) const; bool operator !=(const Vector4& b) const;
// Comparison operators are implemented to allow insertion into sorted containers such as std::set // Comparison operators are implemented to allow insertion into sorted containers such as std::set
bool operator >(const Vector4& b) const; bool operator >(const Vector4& b) const;
bool operator <(const Vector4& b) const; bool operator <(const Vector4& b) const;
float& operator[](unsigned i); float& operator[](unsigned i);
float operator[](unsigned i) const; float operator[](unsigned i) const;
float sqrMagnitude() const; // calculate the square of the magnitude (useful for comparison of magnitudes without the cost of a sqrt() function) float sqrMagnitude() const; // calculate the square of the magnitude (useful for comparison of magnitudes without the cost of a sqrt() function)
float magnitude() const; float magnitude() const;
void normalize(); void normalize();
static Vector4 Normalize(const Vector4 &v); static Vector4 Normalize(const Vector4 &v);
static float Dot(const Vector4 &v1, const Vector4 &v2); static float Dot(const Vector4 &v1, const Vector4 &v2);
static Vector4 Min(); static Vector4 Min();
static Vector4 Max(); static Vector4 Max();
static const Vector4 &Zero(); static const Vector4 &Zero();
static Vector4 One(); static Vector4 One();
static Vector4 Forward(); static Vector4 Forward();
static Vector4 Backward(); static Vector4 Backward();
static Vector4 Up(); static Vector4 Up();
static Vector4 Down(); static Vector4 Down();
static Vector4 Left(); static Vector4 Left();
static Vector4 Right(); static Vector4 Right();
static Vector4 Lerp(const Vector4 &v1, const Vector4 &v2, float d); static Vector4 Lerp(const Vector4 &v1, const Vector4 &v2, float d);
static Vector4 Slerp(const Vector4 &v1, const Vector4 &v2, float d); static Vector4 Slerp(const Vector4 &v1, const Vector4 &v2, float d);
static void OrthoNormalize(Vector4 &normal, Vector4 &tangent); // Gram-Schmidt Orthonormalization static void OrthoNormalize(Vector4 &normal, Vector4 &tangent); // Gram-Schmidt Orthonormalization
}; };
} // namespace kraken } // namespace kraken
@@ -117,6 +117,6 @@ namespace std {
return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3); return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3);
} }
}; };
} } // namespace std
#endif // KRAKEN_VECTOR4_H #endif // KRAKEN_VECTOR4_H