TrinityCore
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
G3D::Quat Class Reference

#include <Quat.h>

Public Member Functions

 Quat ()
 
 Quat (const class Any &a)
 
Any toAny () const
 
 Quat (const Matrix3 &rot)
 
 Quat (float _x, float _y, float _z, float _w)
 
 Quat (const Vector3 &v, float _w=0)
 
bool operator== (const Quat &q) const
 
const float & real () const
 
float & real ()
 
Quat operator- () const
 
Quat operator- (const Quat &other) const
 
Quatoperator-= (const Quat &q)
 
Quat operator+ (const Quat &q) const
 
Quatoperator+= (const Quat &q)
 
Quat conj () const
 
float sum () const
 
float average () const
 
Quat operator* (float s) const
 
Quatoperator*= (float s)
 
Quat operator/ (float s) const
 
float dot (const Quat &other) const
 
bool fuzzyEq (const Quat &q)
 
bool sameRotation (const Quat &q)
 
const Vector3imag () const
 
Vector3imag ()
 
void toAxisAngleRotation (Vector3 &axis, double &angle) const
 
void toAxisAngleRotation (Vector3 &axis, float &angle) const
 
Matrix3 toRotationMatrix () const
 
void toRotationMatrix (Matrix3 &rot) const
 
Quat slerp (const Quat &other, float alpha, float threshold=0.05f) const
 
Quat movedTowards (const Quat &other, float maxAngle) const
 
void moveTowards (const Quat &other, float maxAngle)
 
float angleBetween (const Quat &other) const
 
Quat nlerp (const Quat &other, float alpha) const
 
Quat inverse () const
 
Quat operator* (const Quat &other) const
 
Quat operator/ (const Quat &other) const
 
bool isUnit (float tolerance=1e-5) const
 
float magnitude () const
 
Quat log () const
 
Quat exp () const
 
Quat pow (float r) const
 
void unitize ()
 
Quat toUnit () const
 
float norm () const
 
const float & operator[] (int i) const
 
float & operator[] (int i)
 
void deserialize (class BinaryInput &b)
 
void serialize (class BinaryOutput &b) const
 
Vector2 xx () const
 
Vector2 yx () const
 
Vector2 zx () const
 
Vector2 wx () const
 
Vector2 xy () const
 
Vector2 yy () const
 
Vector2 zy () const
 
Vector2 wy () const
 
Vector2 xz () const
 
Vector2 yz () const
 
Vector2 zz () const
 
Vector2 wz () const
 
Vector2 xw () const
 
Vector2 yw () const
 
Vector2 zw () const
 
Vector2 ww () const
 
Vector3 xxx () const
 
Vector3 yxx () const
 
Vector3 zxx () const
 
Vector3 wxx () const
 
Vector3 xyx () const
 
Vector3 yyx () const
 
Vector3 zyx () const
 
Vector3 wyx () const
 
Vector3 xzx () const
 
Vector3 yzx () const
 
Vector3 zzx () const
 
Vector3 wzx () const
 
Vector3 xwx () const
 
Vector3 ywx () const
 
Vector3 zwx () const
 
Vector3 wwx () const
 
Vector3 xxy () const
 
Vector3 yxy () const
 
Vector3 zxy () const
 
Vector3 wxy () const
 
Vector3 xyy () const
 
Vector3 yyy () const
 
Vector3 zyy () const
 
Vector3 wyy () const
 
Vector3 xzy () const
 
Vector3 yzy () const
 
Vector3 zzy () const
 
Vector3 wzy () const
 
Vector3 xwy () const
 
Vector3 ywy () const
 
Vector3 zwy () const
 
Vector3 wwy () const
 
Vector3 xxz () const
 
Vector3 yxz () const
 
Vector3 zxz () const
 
Vector3 wxz () const
 
Vector3 xyz () const
 
Vector3 yyz () const
 
Vector3 zyz () const
 
Vector3 wyz () const
 
Vector3 xzz () const
 
Vector3 yzz () const
 
Vector3 zzz () const
 
Vector3 wzz () const
 
Vector3 xwz () const
 
Vector3 ywz () const
 
Vector3 zwz () const
 
Vector3 wwz () const
 
Vector3 xxw () const
 
Vector3 yxw () const
 
Vector3 zxw () const
 
Vector3 wxw () const
 
Vector3 xyw () const
 
Vector3 yyw () const
 
Vector3 zyw () const
 
Vector3 wyw () const
 
Vector3 xzw () const
 
Vector3 yzw () const
 
Vector3 zzw () const
 
Vector3 wzw () const
 
Vector3 xww () const
 
Vector3 yww () const
 
Vector3 zww () const
 
Vector3 www () const
 
Vector4 xxxx () const
 
Vector4 yxxx () const
 
Vector4 zxxx () const
 
Vector4 wxxx () const
 
Vector4 xyxx () const
 
Vector4 yyxx () const
 
Vector4 zyxx () const
 
Vector4 wyxx () const
 
Vector4 xzxx () const
 
Vector4 yzxx () const
 
Vector4 zzxx () const
 
Vector4 wzxx () const
 
Vector4 xwxx () const
 
Vector4 ywxx () const
 
Vector4 zwxx () const
 
Vector4 wwxx () const
 
Vector4 xxyx () const
 
Vector4 yxyx () const
 
Vector4 zxyx () const
 
Vector4 wxyx () const
 
Vector4 xyyx () const
 
Vector4 yyyx () const
 
Vector4 zyyx () const
 
Vector4 wyyx () const
 
Vector4 xzyx () const
 
Vector4 yzyx () const
 
Vector4 zzyx () const
 
Vector4 wzyx () const
 
Vector4 xwyx () const
 
Vector4 ywyx () const
 
Vector4 zwyx () const
 
Vector4 wwyx () const
 
Vector4 xxzx () const
 
Vector4 yxzx () const
 
Vector4 zxzx () const
 
Vector4 wxzx () const
 
Vector4 xyzx () const
 
Vector4 yyzx () const
 
Vector4 zyzx () const
 
Vector4 wyzx () const
 
Vector4 xzzx () const
 
Vector4 yzzx () const
 
Vector4 zzzx () const
 
Vector4 wzzx () const
 
Vector4 xwzx () const
 
Vector4 ywzx () const
 
Vector4 zwzx () const
 
Vector4 wwzx () const
 
Vector4 xxwx () const
 
Vector4 yxwx () const
 
Vector4 zxwx () const
 
Vector4 wxwx () const
 
Vector4 xywx () const
 
Vector4 yywx () const
 
Vector4 zywx () const
 
Vector4 wywx () const
 
Vector4 xzwx () const
 
Vector4 yzwx () const
 
Vector4 zzwx () const
 
Vector4 wzwx () const
 
Vector4 xwwx () const
 
Vector4 ywwx () const
 
Vector4 zwwx () const
 
Vector4 wwwx () const
 
Vector4 xxxy () const
 
Vector4 yxxy () const
 
Vector4 zxxy () const
 
Vector4 wxxy () const
 
Vector4 xyxy () const
 
Vector4 yyxy () const
 
Vector4 zyxy () const
 
Vector4 wyxy () const
 
Vector4 xzxy () const
 
Vector4 yzxy () const
 
Vector4 zzxy () const
 
Vector4 wzxy () const
 
Vector4 xwxy () const
 
Vector4 ywxy () const
 
Vector4 zwxy () const
 
Vector4 wwxy () const
 
Vector4 xxyy () const
 
Vector4 yxyy () const
 
Vector4 zxyy () const
 
Vector4 wxyy () const
 
Vector4 xyyy () const
 
Vector4 yyyy () const
 
Vector4 zyyy () const
 
Vector4 wyyy () const
 
Vector4 xzyy () const
 
Vector4 yzyy () const
 
Vector4 zzyy () const
 
Vector4 wzyy () const
 
Vector4 xwyy () const
 
Vector4 ywyy () const
 
Vector4 zwyy () const
 
Vector4 wwyy () const
 
Vector4 xxzy () const
 
Vector4 yxzy () const
 
Vector4 zxzy () const
 
Vector4 wxzy () const
 
Vector4 xyzy () const
 
Vector4 yyzy () const
 
Vector4 zyzy () const
 
Vector4 wyzy () const
 
Vector4 xzzy () const
 
Vector4 yzzy () const
 
Vector4 zzzy () const
 
Vector4 wzzy () const
 
Vector4 xwzy () const
 
Vector4 ywzy () const
 
Vector4 zwzy () const
 
Vector4 wwzy () const
 
Vector4 xxwy () const
 
Vector4 yxwy () const
 
Vector4 zxwy () const
 
Vector4 wxwy () const
 
Vector4 xywy () const
 
Vector4 yywy () const
 
Vector4 zywy () const
 
Vector4 wywy () const
 
Vector4 xzwy () const
 
Vector4 yzwy () const
 
Vector4 zzwy () const
 
Vector4 wzwy () const
 
Vector4 xwwy () const
 
Vector4 ywwy () const
 
Vector4 zwwy () const
 
Vector4 wwwy () const
 
Vector4 xxxz () const
 
Vector4 yxxz () const
 
Vector4 zxxz () const
 
Vector4 wxxz () const
 
Vector4 xyxz () const
 
Vector4 yyxz () const
 
Vector4 zyxz () const
 
Vector4 wyxz () const
 
Vector4 xzxz () const
 
Vector4 yzxz () const
 
Vector4 zzxz () const
 
Vector4 wzxz () const
 
Vector4 xwxz () const
 
Vector4 ywxz () const
 
Vector4 zwxz () const
 
Vector4 wwxz () const
 
Vector4 xxyz () const
 
Vector4 yxyz () const
 
Vector4 zxyz () const
 
Vector4 wxyz () const
 
Vector4 xyyz () const
 
Vector4 yyyz () const
 
Vector4 zyyz () const
 
Vector4 wyyz () const
 
Vector4 xzyz () const
 
Vector4 yzyz () const
 
Vector4 zzyz () const
 
Vector4 wzyz () const
 
Vector4 xwyz () const
 
Vector4 ywyz () const
 
Vector4 zwyz () const
 
Vector4 wwyz () const
 
Vector4 xxzz () const
 
Vector4 yxzz () const
 
Vector4 zxzz () const
 
Vector4 wxzz () const
 
Vector4 xyzz () const
 
Vector4 yyzz () const
 
Vector4 zyzz () const
 
Vector4 wyzz () const
 
Vector4 xzzz () const
 
Vector4 yzzz () const
 
Vector4 zzzz () const
 
Vector4 wzzz () const
 
Vector4 xwzz () const
 
Vector4 ywzz () const
 
Vector4 zwzz () const
 
Vector4 wwzz () const
 
Vector4 xxwz () const
 
Vector4 yxwz () const
 
Vector4 zxwz () const
 
Vector4 wxwz () const
 
Vector4 xywz () const
 
Vector4 yywz () const
 
Vector4 zywz () const
 
Vector4 wywz () const
 
Vector4 xzwz () const
 
Vector4 yzwz () const
 
Vector4 zzwz () const
 
Vector4 wzwz () const
 
Vector4 xwwz () const
 
Vector4 ywwz () const
 
Vector4 zwwz () const
 
Vector4 wwwz () const
 
Vector4 xxxw () const
 
Vector4 yxxw () const
 
Vector4 zxxw () const
 
Vector4 wxxw () const
 
Vector4 xyxw () const
 
Vector4 yyxw () const
 
Vector4 zyxw () const
 
Vector4 wyxw () const
 
Vector4 xzxw () const
 
Vector4 yzxw () const
 
Vector4 zzxw () const
 
Vector4 wzxw () const
 
Vector4 xwxw () const
 
Vector4 ywxw () const
 
Vector4 zwxw () const
 
Vector4 wwxw () const
 
Vector4 xxyw () const
 
Vector4 yxyw () const
 
Vector4 zxyw () const
 
Vector4 wxyw () const
 
Vector4 xyyw () const
 
Vector4 yyyw () const
 
Vector4 zyyw () const
 
Vector4 wyyw () const
 
Vector4 xzyw () const
 
Vector4 yzyw () const
 
Vector4 zzyw () const
 
Vector4 wzyw () const
 
Vector4 xwyw () const
 
Vector4 ywyw () const
 
Vector4 zwyw () const
 
Vector4 wwyw () const
 
Vector4 xxzw () const
 
Vector4 yxzw () const
 
Vector4 zxzw () const
 
Vector4 wxzw () const
 
Vector4 xyzw () const
 
Vector4 yyzw () const
 
Vector4 zyzw () const
 
Vector4 wyzw () const
 
Vector4 xzzw () const
 
Vector4 yzzw () const
 
Vector4 zzzw () const
 
Vector4 wzzw () const
 
Vector4 xwzw () const
 
Vector4 ywzw () const
 
Vector4 zwzw () const
 
Vector4 wwzw () const
 
Vector4 xxww () const
 
Vector4 yxww () const
 
Vector4 zxww () const
 
Vector4 wxww () const
 
Vector4 xyww () const
 
Vector4 yyww () const
 
Vector4 zyww () const
 
Vector4 wyww () const
 
Vector4 xzww () const
 
Vector4 yzww () const
 
Vector4 zzww () const
 
Vector4 wzww () const
 
Vector4 xwww () const
 
Vector4 ywww () const
 
Vector4 zwww () const
 
Vector4 wwww () const
 

Static Public Member Functions

static Quat fromAxisAngleRotation (const Vector3 &axis, float angle)
 
static Quat unitRandom ()
 

Public Attributes

float x
 
float y
 
float z
 
float w
 

Private Member Functions

bool operator< (const Quat &) const
 
bool operator> (const Quat &) const
 
bool operator<= (const Quat &) const
 
bool operator>= (const Quat &) const
 
Quat slerp (const Quat &other, float alpha, float threshold, float maxAngle) const
 

Friends

Quat operator* (float s, const Quat &q)
 

Detailed Description

Arbitrary quaternion (not necessarily unit).

Unit quaternions (aka versors) are used in computer graphics to represent rotation about an axis. Any 3x3 rotation matrix can be stored as a quaternion.

A quaternion represents the sum of a real scalar and an imaginary vector: ix + jy + kz + w. A unit quaternion representing a rotation by A about axis v has the form [sin(A/2)*v, cos(A/2)]. For a unit quaternion, q.conj() == q.inverse() is a rotation by -A about v. -q is the same rotation as q (negate both the axis and angle).

A non-unit quaterion q represents the same rotation as q.unitize() (Dam98 pg 28).

Although quaternion-vector operations (eg. Quat + Vector3) are well defined, they are not supported by this class because they typically are bugs when they appear in code.

Do not subclass.

BETA API – subject to change [Erik] B. Dam, Martin Koch, Martin Lillholm, Quaternions, Interpolation and Animation. Technical Report DIKU-TR-98/5, Department of Computer Science, University of Copenhagen, Denmark. 1998.

Constructor & Destructor Documentation

G3D::Quat::Quat ( )
inline

Initializes to a zero degree rotation, (0,0,0,1)

70 : x(0), y(0), z(0), w(1) {}
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the caller graph for this function:

G3D::Quat::Quat ( const class Any a)

Expects "Quat(x,y,z,w)" or a Matrix3 constructor.

33  {
34  *this = Quat();
35  if (beginsWith(toLower(a.name()), "matrix3")) {
36  *this = a;
37  } else {
38  a.verifyName("Quat");
39  a.verifyType(Any::ARRAY);
40  x = a[0];
41  y = a[1];
42  z = a[2];
43  w = a[3];
44  }
45 }
bool beginsWith(const std::string &test, const std::string &pattern)
Returns true if the test string begins with the pattern string.
Definition: stringutils.cpp:81
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Definition: Any.h:187
float x
Definition: Quat.h:65
std::string toLower(const std::string &x)
Definition: stringutils.cpp:223
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

G3D::Quat::Quat ( const Matrix3 rot)
55  {
56 
57  static const int plus1mod3[] = {1, 2, 0};
58 
59  // Find the index of the largest diagonal component
60  // These ? operations hopefully compile to conditional
61  // move instructions instead of branches.
62  int i = (rot[1][1] > rot[0][0]) ? 1 : 0;
63  i = (rot[2][2] > rot[i][i]) ? 2 : i;
64 
65  // Find the indices of the other elements
66  int j = plus1mod3[i];
67  int k = plus1mod3[j];
68 
69  // Index the elements of the vector part of the quaternion as a float*
70  float* v = (float*)(this);
71 
72  // If we attempted to pre-normalize and trusted the matrix to be
73  // perfectly orthonormal, the result would be:
74  //
75  // double c = sqrt((rot[i][i] - (rot[j][j] + rot[k][k])) + 1.0)
76  // v[i] = -c * 0.5
77  // v[j] = -(rot[i][j] + rot[j][i]) * 0.5 / c
78  // v[k] = -(rot[i][k] + rot[k][i]) * 0.5 / c
79  // w = (rot[j][k] - rot[k][j]) * 0.5 / c
80  //
81  // Since we're going to pay the sqrt anyway, we perform a post normalization, which also
82  // fixes any poorly normalized input. Multiply all elements by 2*c in the above, giving:
83 
84  // nc2 = -c^2
85  double nc2 = ((rot[j][j] + rot[k][k]) - rot[i][i]) - 1.0;
86  v[i] = (float)nc2;
87  w = (rot[j][k] - rot[k][j]);
88  v[j] = -(rot[i][j] + rot[j][i]);
89  v[k] = -(rot[i][k] + rot[k][i]);
90 
91  // We now have the correct result with the wrong magnitude, so normalize it:
92  float s = sqrt(x*x + y*y + z*z + w*w);
93  if (s > 0.00001f) {
94  s = 1.0f / s;
95  x *= s;
96  y *= s;
97  z *= s;
98  w *= s;
99  } else {
100  // The quaternion is nearly zero. Make it 0 0 0 1
101  x = 0.0f;
102  y = 0.0f;
103  z = 0.0f;
104  w = 1.0f;
105  }
106 }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
G3D::Quat::Quat ( float  _x,
float  _y,
float  _z,
float  _w 
)
inline
79  :
80  x(_x), y(_y), z(_z), w(_w) {}
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
G3D::Quat::Quat ( const Vector3 v,
float  _w = 0 
)
inline

Defaults to a pure vector quaternion

83  : x(v.x), y(v.y), z(v.z), w(_w) {
84  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

Member Function Documentation

float G3D::Quat::angleBetween ( const Quat other) const

Returns the angle in radians between this and other, assuming both are unit quaternions.

Returns
On the range [0, pif()]
216  {
217  const float d = this->dot(other);
218  return 2.0f * acos(fabsf(d));
219 }
float dot(const Quat &other) const
Definition: Quat.h:166
float acos(float fValue)
Definition: g3dmath.h:633

+ Here is the call graph for this function:

float G3D::Quat::average ( ) const
inline
142  {
143  return sum() / 4.0f;
144  }
float sum() const
Definition: Quat.h:138

+ Here is the call graph for this function:

Quat G3D::Quat::conj ( ) const
inline

Negates the imaginary part.

134  {
135  return Quat(-x, -y, -z, w);
136  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void G3D::Quat::deserialize ( class BinaryInput b)
258  {
259  x = b.readFloat32();
260  y = b.readFloat32();
261  z = b.readFloat32();
262  w = b.readFloat32();
263 }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

float G3D::Quat::dot ( const Quat other) const
inline
166  {
167  return (x * other.x) + (y * other.y) + (z * other.z) + (w * other.w);
168  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the caller graph for this function:

Quat G3D::Quat::exp ( ) const
inline

exp q = [sin(A) * v, cos(A)] where q = [Av, 0]. Only defined for pure-vector quaternions

321  {
322  debugAssertM(w == 0, "exp only defined for vector quaternions");
323  Vector3 u(x, y, z);
324  float A = u.magnitude();
325  Vector3 v = u / A;
326  return Quat(sinf(A) * v, cosf(A));
327  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
#define debugAssertM(exp, message)
Definition: debugAssert.h:161
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::fromAxisAngleRotation ( const Vector3 axis,
float  angle 
)
static

q = [sin(angle/2)*axis, cos(angle/2)]

22  {
23 
24  Quat q;
25 
26  q.w = cos(angle / 2.0f);
27  q.imag() = axis.direction() * sin(angle / 2.0f);
28 
29  return q;
30 }
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

bool G3D::Quat::fuzzyEq ( const Quat q)
inline

Note: two quats can represent the Quat::sameRotation and not be equal.

171  {
172  return G3D::fuzzyEq(x, q.x) && G3D::fuzzyEq(y, q.y) && G3D::fuzzyEq(z, q.z) && G3D::fuzzyEq(w, q.w);
173  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
bool fuzzyEq(double a, double b)
Definition: g3dmath.h:857

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const Vector3& G3D::Quat::imag ( ) const
inline

Returns the imaginary part (x, y, z)

185  {
186  return *(reinterpret_cast<const Vector3*>(this));
187  }

+ Here is the caller graph for this function:

Vector3& G3D::Quat::imag ( )
inline
189  {
190  return *(reinterpret_cast<Vector3*>(this));
191  }
Quat G3D::Quat::inverse ( ) const
inline

Note that q-1 = q.conj() for a unit quaternion. [Dam99] page 13

273  {
274  return conj() / dot(*this);
275  }
float dot(const Quat &other) const
Definition: Quat.h:166
Quat conj() const
Definition: Quat.h:134

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool G3D::Quat::isUnit ( float  tolerance = 1e-5) const
inline

Is the magnitude nearly 1.0?

289  {
290  return abs(dot(*this) - 1.0f) < tolerance;
291  }
double abs(double fValue)
Definition: g3dmath.h:617
float dot(const Quat &other) const
Definition: Quat.h:166

+ Here is the call graph for this function:

Quat G3D::Quat::log ( ) const
inline
297  {
298  if ((x == 0) && (y == 0) && (z == 0)) {
299  if (w > 0) {
300  return Quat(0, 0, 0, ::logf(w));
301  } else if (w < 0) {
302  // Log of a negative number. Multivalued, any number of the form
303  // (PI * v, ln(-q.w))
304  return Quat((float)pi(), 0, 0, ::logf(-w));
305  } else {
306  // log of zero!
307  return Quat((float)nan(), (float)nan(), (float)nan(), (float)nan());
308  }
309  } else {
310  // Partly imaginary.
311  float imagLen = sqrtf(x * x + y * y + z * z);
312  float len = sqrtf(imagLen * imagLen + w * w);
313  float theta = atan2f(imagLen, (float)w);
314  float t = theta / imagLen;
315  return Quat(t * x, t * y, t * z, ::logf(len));
316  }
317  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
double pi()
Definition: g3dmath.h:147
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65
double nan()
Definition: g3dmath.cpp:77

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

float G3D::Quat::magnitude ( ) const
inline
293  {
294  return sqrtf(dot(*this));
295  }
float dot(const Quat &other) const
Definition: Quat.h:166

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::movedTowards ( const Quat other,
float  maxAngle 
) const
inline

Rotates towards other by at most maxAngle.

251  {
252  return slerp(other, 1.0f, 0.05f, maxAngle);
253  }
Quat slerp(const Quat &other, float alpha, float threshold, float maxAngle) const
Definition: Quat.cpp:165

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void G3D::Quat::moveTowards ( const Quat other,
float  maxAngle 
)
inline

Rotates towards other by at most maxAngle.

258  {
259  *this = movedTowards(other, maxAngle);
260  }
Quat movedTowards(const Quat &other, float maxAngle) const
Definition: Quat.h:250

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::nlerp ( const Quat other,
float  alpha 
) const

Normalized linear interpolation of quaternion components.

224  {
225 
226  Quat result = (*this) * (1.0f - alpha) + quat1 * alpha;
227  return result / result.magnitude();
228 }
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

float G3D::Quat::norm ( ) const
inline

The linear algebra 2-norm, sqrt(q dot q). This matches the value used in Dam's 1998 tech report but differs from the n(q) value used in Eberly's 1999 paper, which is the square of the norm.

363  {
364  return magnitude();
365  }
float magnitude() const
Definition: Quat.h:293

+ Here is the call graph for this function:

Quat G3D::Quat::operator* ( float  s) const
inline
146  {
147  return Quat(x * s, y * s, z * s, w * s);
148  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

Quat G3D::Quat::operator* ( const Quat other) const

Quaternion multiplication (composition of rotations). Note that this does not commute.

231  {
232 
233  // Following Watt & Watt, page 360
234  const Vector3& v1 = imag();
235  const Vector3& v2 = other.imag();
236  float s1 = w;
237  float s2 = other.w;
238 
239  return Quat(s1*v2 + s2*v1 + v1.cross(v2), s1*s2 - v1.dot(v2));
240 }
const Vector3 & imag() const
Definition: Quat.h:185
float w
Definition: Quat.h:65
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

Quat& G3D::Quat::operator*= ( float  s)
inline
150  {
151  x *= s;
152  y *= s;
153  z *= s;
154  w *= s;
155  return *this;
156  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Quat G3D::Quat::operator+ ( const Quat q) const
inline
119  {
120  return Quat(x + q.x, y + q.y, z + q.z, w + q.w);
121  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

Quat& G3D::Quat::operator+= ( const Quat q)
inline
123  {
124  x += q.x;
125  y += q.y;
126  z += q.z;
127  w += q.w;
128  return *this;
129  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Quat G3D::Quat::operator- ( ) const
inline
103  {
104  return Quat(-x, -y, -z, -w);
105  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

Quat G3D::Quat::operator- ( const Quat other) const
inline
107  {
108  return Quat(x - other.x, y - other.y, z - other.z, w - other.w);
109  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

Quat& G3D::Quat::operator-= ( const Quat q)
inline
111  {
112  x -= q.x;
113  y -= q.y;
114  z -= q.z;
115  w -= q.w;
116  return *this;
117  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Quat G3D::Quat::operator/ ( float  s) const
inline
162  {
163  return Quat(x / s, y / s, z / s, w / s);
164  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Quat()
Definition: Quat.h:70
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

Quat G3D::Quat::operator/ ( const Quat other) const
inline
284  {
285  return (*this) * other.inverse();
286  }

+ Here is the call graph for this function:

bool G3D::Quat::operator< ( const Quat ) const
private
bool G3D::Quat::operator<= ( const Quat ) const
private
bool G3D::Quat::operator== ( const Quat q) const
inline

True if the components are exactly equal. Note that two quaternations may be unequal but map to the same rotation.

88  {
89  return x == q.x && y == q.y && z == q.z && w == q.w;
90  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
bool G3D::Quat::operator> ( const Quat ) const
private
bool G3D::Quat::operator>= ( const Quat ) const
private
const float & G3D::Quat::operator[] ( int  i) const
inline
751  {
752  debugAssert(i >= 0);
753  debugAssert(i < 4);
754  return ((float*)this)[i];
755 }
#define debugAssert(exp)
Definition: debugAssert.h:160
float & G3D::Quat::operator[] ( int  i)
inline
745  {
746  debugAssert(i >= 0);
747  debugAssert(i < 4);
748  return ((float*)this)[i];
749 }
#define debugAssert(exp)
Definition: debugAssert.h:160
Quat G3D::Quat::pow ( float  r) const
inline

Raise this quaternion to a power. For a rotation, this is the effect of rotating x times as much as the original quaterion.

Note that q.pow(a).pow(b) == q.pow(a + b) [Dam98] pg 21

338  {
339  return (log() * r).exp();
340  }
Quat log() const
Definition: Quat.h:297

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

const float& G3D::Quat::real ( ) const
inline

The real part of the quaternion.

95  {
96  return w;
97  }
float w
Definition: Quat.h:65
float& G3D::Quat::real ( )
inline
99  {
100  return w;
101  }
float w
Definition: Quat.h:65
bool G3D::Quat::sameRotation ( const Quat q)
inline

True if these quaternions represent the same rotation (note that every rotation is represented by two values; q and -q).

178  {
179  return fuzzyEq(q) || fuzzyEq(-q);
180  }
bool fuzzyEq(const Quat &q)
Definition: Quat.h:171

+ Here is the call graph for this function:

void G3D::Quat::serialize ( class BinaryOutput b) const
266  {
267  b.writeFloat32(x);
268  b.writeFloat32(y);
269  b.writeFloat32(z);
270  b.writeFloat32(w);
271 }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::slerp ( const Quat other,
float  alpha,
float  threshold,
float  maxAngle 
) const
private
Parameters
maxAngleMaximum angle of rotation allowed. If a larger rotation is required, the angle of rotation applied is clamped to maxAngle
168  {
169 
170  // From: Game Physics -- David Eberly pg 538-540
171  // Modified to include lerp for small angles, which
172  // is a common practice.
173 
174  // See also:
175  // http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/index.html
176 
177  const Quat& quat0 = *this;
178  Quat quat1 = _quat1;
179 
180  // angle between quaternion rotations
181  float halfPhi;
182  float cosHalfPhi = quat0.dot(quat1);
183 
184 
185  if (cosHalfPhi < 0) {
186  // Change the sign and fix the dot product; we need to
187  // loop the other way to get the shortest path
188  quat1 = -quat1;
189  cosHalfPhi = -cosHalfPhi;
190  }
191 
192  // Using G3D::aCos will clamp the angle to 0 and pi
193  halfPhi = static_cast<float>(G3D::aCos(cosHalfPhi));
194 
195  debugAssertM(halfPhi >= 0.0f, "Assumed acos returned a value >= 0");
196  if (halfPhi * 2.0f * alpha > maxAngle) {
197  // Back off alpha
198  alpha = maxAngle * 0.5f / halfPhi;
199  }
200 
201  if (halfPhi >= threshold) {
202  // For large angles, slerp
203  float scale0, scale1;
204 
205  scale0 = sin((1.0f - alpha) * halfPhi);
206  scale1 = sin(alpha * halfPhi);
207 
208  return ( (quat0 * scale0) + (quat1 * scale1) ) / sin(halfPhi);
209  } else {
210  // For small angles, linear interpolate
211  return quat0.nlerp(quat1, alpha);
212  }
213 }
#define debugAssertM(exp, message)
Definition: debugAssert.h:161
double aCos(double fValue)
Definition: g3dmath.h:622
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::slerp ( const Quat other,
float  alpha,
float  threshold = 0.05f 
) const
inline

Spherical linear interpolation: linear interpolation along the shortest (3D) great-circle route between two quaternions.

Assumes that both arguments are unit quaternions.

Note: Correct rotations are expected between 0 and PI in the right order.

[Based] on Game Physics – David Eberly pg 538-540

Parameters
thresholdCritical angle between between rotations (in radians) at which the algorithm switches to normalized lerp, which is more numerically stable in those situations. 0.0 will always slerp.
244  {
245  return slerp(other, alpha, threshold, finf());
246  }
float finf()
Definition: g3dmath.cpp:71
Quat slerp(const Quat &other, float alpha, float threshold, float maxAngle) const
Definition: Quat.cpp:165

+ Here is the call graph for this function:

float G3D::Quat::sum ( ) const
inline
138  {
139  return x + y + z + w;
140  }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the caller graph for this function:

Any G3D::Quat::toAny ( ) const
48  {
49  Any a(Any::ARRAY, "Quat");
50  a.append(x, y, z, w);
51  return a;
52 }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Definition: Any.h:187
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65

+ Here is the call graph for this function:

void G3D::Quat::toAxisAngleRotation ( Vector3 axis,
double &  angle 
) const

Returns the axis and angle of rotation represented by this quaternion (i.e. q = [sin(angle/2)*axis, cos(angle/2)])

111  {
112 
113  // Decompose the quaternion into an angle and an axis.
114 
115  axis = Vector3(x, y, z);
116  angle = 2 * acos(w);
117 
118  float len = sqrt(1.0f - w * w);
119 
120  if (fuzzyGt(abs(len), 0.0f)) {
121  axis /= len;
122  }
123 
124  // Reduce the range of the angle.
125 
126  if (angle < 0) {
127  angle = -angle;
128  axis = -axis;
129  }
130 
131  while (angle > twoPi()) {
132  angle -= twoPi();
133  }
134 
135  if (abs(angle) > pi()) {
136  angle -= twoPi();
137  }
138 
139  // Make the angle positive.
140 
141  if (angle < 0.0f) {
142  angle = -angle;
143  axis = -axis;
144  }
145 }
float z
Definition: Quat.h:65
double abs(double fValue)
Definition: g3dmath.h:617
float w
Definition: Quat.h:65
double pi()
Definition: g3dmath.h:147
float x
Definition: Quat.h:65
double twoPi()
Definition: g3dmath.h:159
float acos(float fValue)
Definition: g3dmath.h:633
float y
Definition: Quat.h:65
bool fuzzyGt(double a, double b)
Definition: g3dmath.h:865

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void G3D::Quat::toAxisAngleRotation ( Vector3 axis,
float &  angle 
) const
inline
206  {
207  double d;
208  toAxisAngleRotation(axis, d);
209  angle = (float)d;
210  }
void toAxisAngleRotation(Vector3 &axis, double &angle) const
Definition: Quat.cpp:109

+ Here is the call graph for this function:

Matrix3 G3D::Quat::toRotationMatrix ( ) const
148  {
149  Matrix3 out = Matrix3::zero();
150 
151  toRotationMatrix(out);
152 
153  return out;
154 }
Matrix3 toRotationMatrix() const
Definition: Quat.cpp:148
static const Matrix3 & zero()
Definition: Matrix3.cpp:65

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void G3D::Quat::toRotationMatrix ( Matrix3 rot) const
158  {
159 
160  rot = Matrix3(*this);
161 }
Quat G3D::Quat::toUnit ( ) const
inline

Returns a unit quaterion obtained by dividing through by the magnitude.

351  {
352  Quat copyOfThis = *this;
353  copyOfThis.unitize();
354  return copyOfThis;
355  }
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

void G3D::Quat::unitize ( )
inline

Make unit length in place

343  {
344  *this *= rsq(dot(*this));
345  }
float dot(const Quat &other) const
Definition: Quat.h:166
float rsq(float x)
Definition: g3dmath.h:380

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Quat G3D::Quat::unitRandom ( )
static

Generate uniform random unit quaternion (i.e. random "direction") [From] "Uniform Random Rotations", Ken Shoemake, Graphics Gems III.

244  {
245  float x0 = uniformRandom();
246  float r1 = sqrtf(1 - x0),
247  r2 = sqrtf(x0);
248  float t1 = (float)G3D::twoPi() * uniformRandom();
249  float t2 = (float)G3D::twoPi() * uniformRandom();
250  float c1 = cosf(t1),
251  s1 = sinf(t1);
252  float c2 = cosf(t2),
253  s2 = sinf(t2);
254  return Quat(s1 * r1, c1 * r1, s2 * r2, c2 * r2);
255 }
float uniformRandom(float low=0.0f, float hi=1.0f)
Definition: g3dmath.h:694
double twoPi()
Definition: g3dmath.h:159
Quat()
Definition: Quat.h:70

+ Here is the call graph for this function:

Vector2 G3D::Quat::ww ( ) const
291 { return Vector2 (w, w); }
float w
Definition: Quat.h:65
Vector3 G3D::Quat::www ( ) const
358 { return Vector3 (w, w, w); }
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wwww ( ) const
617 { return Vector4 (w, w, w, w); }
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wwwx ( ) const
425 { return Vector4 (w, w, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wwwy ( ) const
489 { return Vector4 (w, w, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwwz ( ) const
553 { return Vector4 (w, w, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::wwx ( ) const
310 { return Vector3 (w, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wwxw ( ) const
569 { return Vector4 (w, w, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wwxx ( ) const
377 { return Vector4 (w, w, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wwxy ( ) const
441 { return Vector4 (w, w, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwxz ( ) const
505 { return Vector4 (w, w, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::wwy ( ) const
326 { return Vector3 (w, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwyw ( ) const
585 { return Vector4 (w, w, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwyx ( ) const
393 { return Vector4 (w, w, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwyy ( ) const
457 { return Vector4 (w, w, y, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwyz ( ) const
521 { return Vector4 (w, w, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wwz ( ) const
342 { return Vector3 (w, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wwzw ( ) const
601 { return Vector4 (w, w, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wwzx ( ) const
409 { return Vector4 (w, w, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wwzy ( ) const
473 { return Vector4 (w, w, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wwzz ( ) const
537 { return Vector4 (w, w, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector2 G3D::Quat::wx ( ) const
279 { return Vector2 (w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::wxw ( ) const
346 { return Vector3 (w, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxww ( ) const
605 { return Vector4 (w, x, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxwx ( ) const
413 { return Vector4 (w, x, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxwy ( ) const
477 { return Vector4 (w, x, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxwz ( ) const
541 { return Vector4 (w, x, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::wxx ( ) const
298 { return Vector3 (w, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxxw ( ) const
557 { return Vector4 (w, x, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxxx ( ) const
365 { return Vector4 (w, x, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxxy ( ) const
429 { return Vector4 (w, x, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxxz ( ) const
493 { return Vector4 (w, x, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::wxy ( ) const
314 { return Vector3 (w, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxyw ( ) const
573 { return Vector4 (w, x, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxyx ( ) const
381 { return Vector4 (w, x, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxyy ( ) const
445 { return Vector4 (w, x, y, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxyz ( ) const
509 { return Vector4 (w, x, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wxz ( ) const
330 { return Vector3 (w, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxzw ( ) const
589 { return Vector4 (w, x, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxzx ( ) const
397 { return Vector4 (w, x, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wxzy ( ) const
461 { return Vector4 (w, x, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wxzz ( ) const
525 { return Vector4 (w, x, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector2 G3D::Quat::wy ( ) const
283 { return Vector2 (w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wyw ( ) const
350 { return Vector3 (w, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyww ( ) const
609 { return Vector4 (w, y, w, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wywx ( ) const
417 { return Vector4 (w, y, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wywy ( ) const
481 { return Vector4 (w, y, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wywz ( ) const
545 { return Vector4 (w, y, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wyx ( ) const
302 { return Vector3 (w, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyxw ( ) const
561 { return Vector4 (w, y, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyxx ( ) const
369 { return Vector4 (w, y, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyxy ( ) const
433 { return Vector4 (w, y, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyxz ( ) const
497 { return Vector4 (w, y, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wyy ( ) const
318 { return Vector3 (w, y, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyyw ( ) const
577 { return Vector4 (w, y, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyyx ( ) const
385 { return Vector4 (w, y, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyyy ( ) const
449 { return Vector4 (w, y, y, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyyz ( ) const
513 { return Vector4 (w, y, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wyz ( ) const
334 { return Vector3 (w, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyzw ( ) const
593 { return Vector4 (w, y, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyzx ( ) const
401 { return Vector4 (w, y, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyzy ( ) const
465 { return Vector4 (w, y, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wyzz ( ) const
529 { return Vector4 (w, y, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::wz ( ) const
287 { return Vector2 (w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::wzw ( ) const
354 { return Vector3 (w, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wzww ( ) const
613 { return Vector4 (w, z, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wzwx ( ) const
421 { return Vector4 (w, z, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wzwy ( ) const
485 { return Vector4 (w, z, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzwz ( ) const
549 { return Vector4 (w, z, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::wzx ( ) const
306 { return Vector3 (w, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wzxw ( ) const
565 { return Vector4 (w, z, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wzxx ( ) const
373 { return Vector4 (w, z, x, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wzxy ( ) const
437 { return Vector4 (w, z, x, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzxz ( ) const
501 { return Vector4 (w, z, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::wzy ( ) const
322 { return Vector3 (w, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzyw ( ) const
581 { return Vector4 (w, z, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzyx ( ) const
389 { return Vector4 (w, z, y, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzyy ( ) const
453 { return Vector4 (w, z, y, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzyz ( ) const
517 { return Vector4 (w, z, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::wzz ( ) const
338 { return Vector3 (w, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wzzw ( ) const
597 { return Vector4 (w, z, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::wzzx ( ) const
405 { return Vector4 (w, z, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::wzzy ( ) const
469 { return Vector4 (w, z, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::wzzz ( ) const
533 { return Vector4 (w, z, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector2 G3D::Quat::xw ( ) const
288 { return Vector2 (x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xww ( ) const
355 { return Vector3 (x, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwww ( ) const
614 { return Vector4 (x, w, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwwx ( ) const
422 { return Vector4 (x, w, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwwy ( ) const
486 { return Vector4 (x, w, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwwz ( ) const
550 { return Vector4 (x, w, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xwx ( ) const
307 { return Vector3 (x, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwxw ( ) const
566 { return Vector4 (x, w, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwxx ( ) const
374 { return Vector4 (x, w, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwxy ( ) const
438 { return Vector4 (x, w, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwxz ( ) const
502 { return Vector4 (x, w, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xwy ( ) const
323 { return Vector3 (x, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwyw ( ) const
582 { return Vector4 (x, w, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwyx ( ) const
390 { return Vector4 (x, w, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwyy ( ) const
454 { return Vector4 (x, w, y, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwyz ( ) const
518 { return Vector4 (x, w, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xwz ( ) const
339 { return Vector3 (x, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwzw ( ) const
598 { return Vector4 (x, w, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwzx ( ) const
406 { return Vector4 (x, w, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xwzy ( ) const
470 { return Vector4 (x, w, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xwzz ( ) const
534 { return Vector4 (x, w, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector2 G3D::Quat::xx ( ) const
276 { return Vector2 (x, x); }
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xxw ( ) const
343 { return Vector3 (x, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxww ( ) const
602 { return Vector4 (x, x, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxwx ( ) const
410 { return Vector4 (x, x, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxwy ( ) const
474 { return Vector4 (x, x, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxwz ( ) const
538 { return Vector4 (x, x, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xxx ( ) const
295 { return Vector3 (x, x, x); }
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxxw ( ) const
554 { return Vector4 (x, x, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxxx ( ) const
362 { return Vector4 (x, x, x, x); }
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxxy ( ) const
426 { return Vector4 (x, x, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxxz ( ) const
490 { return Vector4 (x, x, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xxy ( ) const
311 { return Vector3 (x, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxyw ( ) const
570 { return Vector4 (x, x, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxyx ( ) const
378 { return Vector4 (x, x, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxyy ( ) const
442 { return Vector4 (x, x, y, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxyz ( ) const
506 { return Vector4 (x, x, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xxz ( ) const
327 { return Vector3 (x, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxzw ( ) const
586 { return Vector4 (x, x, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxzx ( ) const
394 { return Vector4 (x, x, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xxzy ( ) const
458 { return Vector4 (x, x, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xxzz ( ) const
522 { return Vector4 (x, x, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector2 G3D::Quat::xy ( ) const
280 { return Vector2 (x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xyw ( ) const
347 { return Vector3 (x, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyww ( ) const
606 { return Vector4 (x, y, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xywx ( ) const
414 { return Vector4 (x, y, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xywy ( ) const
478 { return Vector4 (x, y, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xywz ( ) const
542 { return Vector4 (x, y, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xyx ( ) const
299 { return Vector3 (x, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyxw ( ) const
558 { return Vector4 (x, y, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyxx ( ) const
366 { return Vector4 (x, y, x, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyxy ( ) const
430 { return Vector4 (x, y, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyxz ( ) const
494 { return Vector4 (x, y, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xyy ( ) const
315 { return Vector3 (x, y, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyyw ( ) const
574 { return Vector4 (x, y, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyyx ( ) const
382 { return Vector4 (x, y, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyyy ( ) const
446 { return Vector4 (x, y, y, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyyz ( ) const
510 { return Vector4 (x, y, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xyz ( ) const
331 { return Vector3 (x, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyzw ( ) const
590 { return Vector4 (x, y, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyzx ( ) const
398 { return Vector4 (x, y, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyzy ( ) const
462 { return Vector4 (x, y, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xyzz ( ) const
526 { return Vector4 (x, y, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::xz ( ) const
284 { return Vector2 (x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xzw ( ) const
351 { return Vector3 (x, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzww ( ) const
610 { return Vector4 (x, z, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzwx ( ) const
418 { return Vector4 (x, z, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzwy ( ) const
482 { return Vector4 (x, z, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzwz ( ) const
546 { return Vector4 (x, z, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xzx ( ) const
303 { return Vector3 (x, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzxw ( ) const
562 { return Vector4 (x, z, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzxx ( ) const
370 { return Vector4 (x, z, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzxy ( ) const
434 { return Vector4 (x, z, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzxz ( ) const
498 { return Vector4 (x, z, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::xzy ( ) const
319 { return Vector3 (x, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzyw ( ) const
578 { return Vector4 (x, z, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzyx ( ) const
386 { return Vector4 (x, z, y, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzyy ( ) const
450 { return Vector4 (x, z, y, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzyz ( ) const
514 { return Vector4 (x, z, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::xzz ( ) const
335 { return Vector3 (x, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzzw ( ) const
594 { return Vector4 (x, z, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzzx ( ) const
402 { return Vector4 (x, z, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::xzzy ( ) const
466 { return Vector4 (x, z, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::xzzz ( ) const
530 { return Vector4 (x, z, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector2 G3D::Quat::yw ( ) const
289 { return Vector2 (y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yww ( ) const
356 { return Vector3 (y, w, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywww ( ) const
615 { return Vector4 (y, w, w, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywwx ( ) const
423 { return Vector4 (y, w, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywwy ( ) const
487 { return Vector4 (y, w, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywwz ( ) const
551 { return Vector4 (y, w, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::ywx ( ) const
308 { return Vector3 (y, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywxw ( ) const
567 { return Vector4 (y, w, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywxx ( ) const
375 { return Vector4 (y, w, x, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywxy ( ) const
439 { return Vector4 (y, w, x, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywxz ( ) const
503 { return Vector4 (y, w, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::ywy ( ) const
324 { return Vector3 (y, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywyw ( ) const
583 { return Vector4 (y, w, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywyx ( ) const
391 { return Vector4 (y, w, y, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywyy ( ) const
455 { return Vector4 (y, w, y, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywyz ( ) const
519 { return Vector4 (y, w, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::ywz ( ) const
340 { return Vector3 (y, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywzw ( ) const
599 { return Vector4 (y, w, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywzx ( ) const
407 { return Vector4 (y, w, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywzy ( ) const
471 { return Vector4 (y, w, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::ywzz ( ) const
535 { return Vector4 (y, w, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::yx ( ) const
277 { return Vector2 (y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yxw ( ) const
344 { return Vector3 (y, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxww ( ) const
603 { return Vector4 (y, x, w, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxwx ( ) const
411 { return Vector4 (y, x, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxwy ( ) const
475 { return Vector4 (y, x, w, y); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxwz ( ) const
539 { return Vector4 (y, x, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yxx ( ) const
296 { return Vector3 (y, x, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxxw ( ) const
555 { return Vector4 (y, x, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxxx ( ) const
363 { return Vector4 (y, x, x, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxxy ( ) const
427 { return Vector4 (y, x, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxxz ( ) const
491 { return Vector4 (y, x, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yxy ( ) const
312 { return Vector3 (y, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxyw ( ) const
571 { return Vector4 (y, x, y, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxyx ( ) const
379 { return Vector4 (y, x, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxyy ( ) const
443 { return Vector4 (y, x, y, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxyz ( ) const
507 { return Vector4 (y, x, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yxz ( ) const
328 { return Vector3 (y, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxzw ( ) const
587 { return Vector4 (y, x, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxzx ( ) const
395 { return Vector4 (y, x, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxzy ( ) const
459 { return Vector4 (y, x, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yxzz ( ) const
523 { return Vector4 (y, x, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::yy ( ) const
281 { return Vector2 (y, y); }
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yyw ( ) const
348 { return Vector3 (y, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyww ( ) const
607 { return Vector4 (y, y, w, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yywx ( ) const
415 { return Vector4 (y, y, w, x); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yywy ( ) const
479 { return Vector4 (y, y, w, y); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yywz ( ) const
543 { return Vector4 (y, y, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yyx ( ) const
300 { return Vector3 (y, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyxw ( ) const
559 { return Vector4 (y, y, x, w); }
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyxx ( ) const
367 { return Vector4 (y, y, x, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyxy ( ) const
431 { return Vector4 (y, y, x, y); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyxz ( ) const
495 { return Vector4 (y, y, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yyy ( ) const
316 { return Vector3 (y, y, y); }
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyyw ( ) const
575 { return Vector4 (y, y, y, w); }
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyyx ( ) const
383 { return Vector4 (y, y, y, x); }
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyyy ( ) const
447 { return Vector4 (y, y, y, y); }
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyyz ( ) const
511 { return Vector4 (y, y, y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yyz ( ) const
332 { return Vector3 (y, y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyzw ( ) const
591 { return Vector4 (y, y, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyzx ( ) const
399 { return Vector4 (y, y, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyzy ( ) const
463 { return Vector4 (y, y, z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yyzz ( ) const
527 { return Vector4 (y, y, z, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::yz ( ) const
285 { return Vector2 (y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yzw ( ) const
352 { return Vector3 (y, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzww ( ) const
611 { return Vector4 (y, z, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzwx ( ) const
419 { return Vector4 (y, z, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzwy ( ) const
483 { return Vector4 (y, z, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzwz ( ) const
547 { return Vector4 (y, z, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yzx ( ) const
304 { return Vector3 (y, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzxw ( ) const
563 { return Vector4 (y, z, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzxx ( ) const
371 { return Vector4 (y, z, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzxy ( ) const
435 { return Vector4 (y, z, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzxz ( ) const
499 { return Vector4 (y, z, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yzy ( ) const
320 { return Vector3 (y, z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzyw ( ) const
579 { return Vector4 (y, z, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzyx ( ) const
387 { return Vector4 (y, z, y, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzyy ( ) const
451 { return Vector4 (y, z, y, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzyz ( ) const
515 { return Vector4 (y, z, y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::yzz ( ) const
336 { return Vector3 (y, z, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzzw ( ) const
595 { return Vector4 (y, z, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzzx ( ) const
403 { return Vector4 (y, z, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzzy ( ) const
467 { return Vector4 (y, z, z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::yzzz ( ) const
531 { return Vector4 (y, z, z, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::zw ( ) const
290 { return Vector2 (z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::zww ( ) const
357 { return Vector3 (z, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zwww ( ) const
616 { return Vector4 (z, w, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zwwx ( ) const
424 { return Vector4 (z, w, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zwwy ( ) const
488 { return Vector4 (z, w, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwwz ( ) const
552 { return Vector4 (z, w, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::zwx ( ) const
309 { return Vector3 (z, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zwxw ( ) const
568 { return Vector4 (z, w, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zwxx ( ) const
376 { return Vector4 (z, w, x, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zwxy ( ) const
440 { return Vector4 (z, w, x, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwxz ( ) const
504 { return Vector4 (z, w, x, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::zwy ( ) const
325 { return Vector3 (z, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwyw ( ) const
584 { return Vector4 (z, w, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwyx ( ) const
392 { return Vector4 (z, w, y, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwyy ( ) const
456 { return Vector4 (z, w, y, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwyz ( ) const
520 { return Vector4 (z, w, y, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zwz ( ) const
341 { return Vector3 (z, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zwzw ( ) const
600 { return Vector4 (z, w, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zwzx ( ) const
408 { return Vector4 (z, w, z, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zwzy ( ) const
472 { return Vector4 (z, w, z, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zwzz ( ) const
536 { return Vector4 (z, w, z, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector2 G3D::Quat::zx ( ) const
278 { return Vector2 (z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::zxw ( ) const
345 { return Vector3 (z, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxww ( ) const
604 { return Vector4 (z, x, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxwx ( ) const
412 { return Vector4 (z, x, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxwy ( ) const
476 { return Vector4 (z, x, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxwz ( ) const
540 { return Vector4 (z, x, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::zxx ( ) const
297 { return Vector3 (z, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxxw ( ) const
556 { return Vector4 (z, x, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxxx ( ) const
364 { return Vector4 (z, x, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxxy ( ) const
428 { return Vector4 (z, x, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxxz ( ) const
492 { return Vector4 (z, x, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::zxy ( ) const
313 { return Vector3 (z, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxyw ( ) const
572 { return Vector4 (z, x, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxyx ( ) const
380 { return Vector4 (z, x, y, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxyy ( ) const
444 { return Vector4 (z, x, y, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxyz ( ) const
508 { return Vector4 (z, x, y, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zxz ( ) const
329 { return Vector3 (z, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxzw ( ) const
588 { return Vector4 (z, x, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxzx ( ) const
396 { return Vector4 (z, x, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zxzy ( ) const
460 { return Vector4 (z, x, z, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zxzz ( ) const
524 { return Vector4 (z, x, z, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector2 G3D::Quat::zy ( ) const
282 { return Vector2 (z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zyw ( ) const
349 { return Vector3 (z, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyww ( ) const
608 { return Vector4 (z, y, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zywx ( ) const
416 { return Vector4 (z, y, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zywy ( ) const
480 { return Vector4 (z, y, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zywz ( ) const
544 { return Vector4 (z, y, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zyx ( ) const
301 { return Vector3 (z, y, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyxw ( ) const
560 { return Vector4 (z, y, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyxx ( ) const
368 { return Vector4 (z, y, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyxy ( ) const
432 { return Vector4 (z, y, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyxz ( ) const
496 { return Vector4 (z, y, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zyy ( ) const
317 { return Vector3 (z, y, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyyw ( ) const
576 { return Vector4 (z, y, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyyx ( ) const
384 { return Vector4 (z, y, y, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyyy ( ) const
448 { return Vector4 (z, y, y, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyyz ( ) const
512 { return Vector4 (z, y, y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector3 G3D::Quat::zyz ( ) const
333 { return Vector3 (z, y, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyzw ( ) const
592 { return Vector4 (z, y, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyzx ( ) const
400 { return Vector4 (z, y, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyzy ( ) const
464 { return Vector4 (z, y, z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zyzz ( ) const
528 { return Vector4 (z, y, z, z); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector2 G3D::Quat::zz ( ) const
286 { return Vector2 (z, z); }
float z
Definition: Quat.h:65
Vector3 G3D::Quat::zzw ( ) const
353 { return Vector3 (z, z, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zzww ( ) const
612 { return Vector4 (z, z, w, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector4 G3D::Quat::zzwx ( ) const
420 { return Vector4 (z, z, w, x); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zzwy ( ) const
484 { return Vector4 (z, z, w, y); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zzwz ( ) const
548 { return Vector4 (z, z, w, z); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
Vector3 G3D::Quat::zzx ( ) const
305 { return Vector3 (z, z, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zzxw ( ) const
564 { return Vector4 (z, z, x, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zzxx ( ) const
372 { return Vector4 (z, z, x, x); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector4 G3D::Quat::zzxy ( ) const
436 { return Vector4 (z, z, x, y); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zzxz ( ) const
500 { return Vector4 (z, z, x, z); }
float z
Definition: Quat.h:65
float x
Definition: Quat.h:65
Vector3 G3D::Quat::zzy ( ) const
321 { return Vector3 (z, z, y); }
float z
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zzyw ( ) const
580 { return Vector4 (z, z, y, w); }
float z
Definition: Quat.h:65
float w
Definition: Quat.h:65
float y
Definition: Quat.h:65
Vector4 G3D::Quat::zzyx ( ) const
388 { return Vector4 (z, z,