HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
quath.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the terms set forth in the LICENSE.txt file available at
5 // https://openusd.org/license.
6 //
7 ////////////////////////////////////////////////////////////////////////
8 // This file is generated by a script. Do not edit directly. Edit the
9 // quat.template.h file to make changes.
10 
11 #ifndef PXR_BASE_GF_QUATH_H
12 #define PXR_BASE_GF_QUATH_H
13 
14 /// \file gf/quath.h
15 /// \ingroup group_gf_LinearAlgebra
16 
17 #include "pxr/pxr.h"
18 #include "pxr/base/gf/api.h"
19 #include "pxr/base/gf/declare.h"
20 #include "pxr/base/gf/vec3h.h"
21 #include "pxr/base/gf/traits.h"
22 #include "pxr/base/gf/half.h"
23 #include "pxr/base/tf/hash.h"
24 
25 #include <iosfwd>
26 
28 
29 template <>
30 struct GfIsGfQuat<class GfQuath> { static const bool value = true; };
31 
32 
33 /// Return the dot (inner) product of two quaternions.
34 GfHalf GfDot(const GfQuath& q1, const GfQuath& q2);
35 
36 
37 /// \class GfQuath
38 /// \ingroup group_gf_LinearAlgebra
39 ///
40 /// Basic type: a quaternion, a complex number with a real coefficient and
41 /// three imaginary coefficients, stored as a 3-vector.
42 ///
43 class GfQuath
44 {
45  public:
46  typedef GfHalf ScalarType;
48 
49  /// Default constructor leaves the quaternion undefined.
50  GfQuath() {}
51 
52  /// Initialize the real coefficient to \p realVal and the imaginary
53  /// coefficients to zero.
54  ///
55  /// Since quaternions typically must be normalized, reasonable values for
56  /// \p realVal are -1, 0, or 1. Other values are legal but are likely to
57  /// be meaningless.
58  ///
59  explicit GfQuath (GfHalf realVal) : _imaginary(0), _real(realVal) {}
60 
61  /// Initialize the real and imaginary coefficients.
63  : _imaginary(i, j, k), _real(real)
64  {
65  }
66 
67  /// Initialize the real and imaginary coefficients.
68  GfQuath(GfHalf real, const GfVec3h &imaginary)
69  : _imaginary(imaginary), _real(real)
70  {
71  }
72 
73  /// Construct from GfQuatd.
74  GF_API
75  explicit GfQuath(class GfQuatd const &other);
76  /// Construct from GfQuatf.
77  GF_API
78  explicit GfQuath(class GfQuatf const &other);
79 
80  /// Return the zero quaternion, with real coefficient 0 and an
81  /// imaginary coefficients all zero.
82  static GfQuath GetZero() { return GfQuath(0.0); }
83 
84  /// Return the identity quaternion, with real coefficient 1 and an
85  /// imaginary coefficients all zero.
86  static GfQuath GetIdentity() { return GfQuath(1.0); }
87 
88  /// Return the real coefficient.
89  GfHalf GetReal() const { return _real; }
90 
91  /// Set the real coefficient.
92  void SetReal(GfHalf real) { _real = real; }
93 
94  /// Return the imaginary coefficient.
95  const GfVec3h &GetImaginary() const { return _imaginary; }
96 
97  /// Set the imaginary coefficients.
98  void SetImaginary(const GfVec3h &imaginary) {
99  _imaginary = imaginary;
100  }
101 
102  /// Set the imaginary coefficients.
104  _imaginary.Set(i, j, k);
105  }
106 
107  /// Return geometric length of this quaternion.
108  GfHalf GetLength() const { return GfSqrt(_GetLengthSquared()); }
109 
110  /// length of this quaternion is smaller than \p eps, return the identity
111  /// quaternion.
112  GfQuath
114  GfQuath ret(*this);
115  ret.Normalize(eps);
116  return ret;
117  }
118 
119  /// Normalizes this quaternion in place to unit length, returning the
120  /// length before normalization. If the length of this quaternion is
121  /// smaller than \p eps, this sets the quaternion to identity.
122  GF_API
124 
125  /// Return this quaternion's conjugate, which is the quaternion with the
126  /// same real coefficient and negated imaginary coefficients.
128  return GfQuath(GetReal(), -GetImaginary());
129  }
130 
131  /// Return this quaternion's inverse, or reciprocal. This is the
132  /// quaternion's conjugate divided by it's squared length.
133  GfQuath GetInverse() const {
134  return GetConjugate() / _GetLengthSquared();
135  }
136 
137  /// Transform the GfVec3h point. If the quaternion is normalized,
138  /// the transformation is a rotation. Given a GfQuath q, q.Transform(point)
139  /// is equivalent to:
140  ///
141  /// (q * GfQuath(0, point) * q.GetInverse()).GetImaginary()
142  ///
143  /// but is more efficient.
144  GF_API
145  GfVec3h Transform(const GfVec3h& point) const;
146 
147  /// Hash.
148  friend inline size_t hash_value(const GfQuath &q) {
149  return TfHash::Combine(q.GetReal(), q.GetImaginary());
150  }
151 
152  /// Component-wise negation.
153  GfQuath operator-() const {
154  return GfQuath(-GetReal(), -GetImaginary());
155  }
156 
157  /// Component-wise quaternion equality test. The real and imaginary parts
158  /// must match exactly for quaternions to be considered equal.
159  bool operator==(const GfQuath &q) const {
160  return (GetReal() == q.GetReal() &&
161  GetImaginary() == q.GetImaginary());
162  }
163 
164  /// Component-wise quaternion inequality test. The real and imaginary
165  /// parts must match exactly for quaternions to be considered equal.
166  bool operator!=(const GfQuath &q) const {
167  return !(*this == q);
168  }
169 
170  /// Post-multiply quaternion \p q into this quaternion.
171  GF_API
172  GfQuath &operator *=(const GfQuath &q);
173 
174  /// Multiply this quaternion's coefficients by \p s.
176  _real *= s;
177  _imaginary *= s;
178  return *this;
179  }
180 
181  /// Divide this quaternion's coefficients by \p s.
183  _real /= s;
184  _imaginary /= s;
185  return *this;
186  }
187 
188  /// Add quaternion \p q to this quaternion.
190  _real += q._real;
191  _imaginary += q._imaginary;
192  return *this;
193  }
194 
195  /// Component-wise unary difference operator.
197  _real -= q._real;
198  _imaginary -= q._imaginary;
199  return *this;
200  }
201 
202  /// Component-wise binary sum operator.
203  friend GfQuath
204  operator +(const GfQuath &q1, const GfQuath &q2) {
205  return GfQuath(q1) += q2;
206  }
207 
208  /// Component-wise binary difference operator.
209  friend GfQuath
210  operator -(const GfQuath &q1, const GfQuath &q2) {
211  return GfQuath(q1) -= q2;
212  }
213 
214  /// Returns the product of quaternions \p q1 and \p q2.
215  friend GfQuath
216  operator *(const GfQuath &q1, const GfQuath &q2) {
217  return GfQuath(q1) *= q2;
218  }
219 
220  /// Returns the product of quaternion \p q and scalar \p s.
221  friend GfQuath
223  return GfQuath(q) *= s;
224  }
225 
226  /// Returns the product of quaternion \p q and scalar \p s.
227  friend GfQuath
229  return GfQuath(q) *= s;
230  }
231 
232  /// Returns the product of quaternion \p q and scalar 1 / \p s.
233  friend GfQuath
235  return GfQuath(q) /= s;
236  }
237 
238  private:
239  /// Imaginary part
240  GfVec3h _imaginary;
241 
242  /// Real part
243  GfHalf _real;
244 
245  /// Returns the square of the length
246  GfHalf
247  _GetLengthSquared() const {
248  return GfDot(*this, *this);
249  }
250 };
251 
252 /// Spherically linearly interpolate between \p q0 and \p q1.
253 ///
254 /// If the interpolant \p alpha is zero, then the result is \p q0, while
255 /// \p alpha of one yields \p q1.
257 GfSlerp(double alpha, const GfQuath& q0, const GfQuath& q1);
258 
260 GfSlerp(const GfQuath& q0, const GfQuath& q1, double alpha);
261 
262 inline GfHalf
263 GfDot(GfQuath const &q1, GfQuath const &q2) {
264  return GfDot(q1.GetImaginary(), q2.GetImaginary()) +
265  q1.GetReal()*q2.GetReal();
266 }
267 
268 /// Output a GfQuatd using the format (re, i, j, k)
269 /// \ingroup group_gf_DebuggingOutput
270 GF_API std::ostream& operator<<(std::ostream &, GfQuath const &);
271 
273 
274 #endif // PXR_BASE_GF_QUATH_H
Definition: quath.h:43
void SetImaginary(GfHalf i, GfHalf j, GfHalf k)
Set the imaginary coefficients.
Definition: quath.h:103
friend GfQuath operator+(const GfQuath &q1, const GfQuath &q2)
Component-wise binary sum operator.
Definition: quath.h:204
GfHalf GetLength() const
Return geometric length of this quaternion.
Definition: quath.h:108
double GfSqrt(double f)
Definition: math.h:187
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the and then *wait for them to all complete We provide a helper class
Definition: thread.h:632
bool operator!=(const GfQuath &q) const
Definition: quath.h:166
GLsizei const GLfloat * value
Definition: glcorearb.h:824
static GfQuath GetZero()
Definition: quath.h:82
GfQuath(GfHalf real, GfHalf i, GfHalf j, GfHalf k)
Initialize the real and imaginary coefficients.
Definition: quath.h:62
void SetImaginary(const GfVec3h &imaginary)
Set the imaginary coefficients.
Definition: quath.h:98
GfQuath(GfHalf realVal)
Definition: quath.h:59
GLdouble s
Definition: glad.h:3009
GF_API std::ostream & operator<<(std::ostream &, GfQuath const &)
friend GfQuath operator*(const GfQuath &q1, const GfQuath &q2)
Returns the product of quaternions q1 and q2.
Definition: quath.h:216
GfQuath & operator/=(GfHalf s)
Divide this quaternion's coefficients by s.
Definition: quath.h:182
GLdouble GLdouble GLdouble q
Definition: glad.h:2445
Definition: quatf.h:42
static GfQuath GetIdentity()
Definition: quath.h:86
bool operator==(const GfQuath &q) const
Definition: quath.h:159
GfQuath()
Default constructor leaves the quaternion undefined.
Definition: quath.h:50
GfQuath & operator-=(const GfQuath &q)
Component-wise unary difference operator.
Definition: quath.h:196
GfHalf GetReal() const
Return the real coefficient.
Definition: quath.h:89
GfQuath(GfHalf real, const GfVec3h &imaginary)
Initialize the real and imaginary coefficients.
Definition: quath.h:68
const GfVec3h & GetImaginary() const
Return the imaginary coefficient.
Definition: quath.h:95
friend size_t hash_value(const GfQuath &q)
Hash.
Definition: quath.h:148
friend GfQuath operator/(const GfQuath &q, GfHalf s)
Returns the product of quaternion q and scalar 1 / s.
Definition: quath.h:234
GfQuath GetConjugate() const
Definition: quath.h:127
GF_API GfVec3h Transform(const GfVec3h &point) const
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
GfQuath GetInverse() const
Definition: quath.h:133
GF_API GfHalf Normalize(GfHalf eps=GF_MIN_VECTOR_LENGTH)
GLint j
Definition: glad.h:2733
GfVec3h ImaginaryType
Definition: quath.h:47
static size_t Combine(Args &&...args)
Produce a hash code by combining the hash codes of several objects.
Definition: hash.h:487
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1425
GfQuath operator-() const
Component-wise negation.
Definition: quath.h:153
GfHalf GfDot(const GfQuath &q1, const GfQuath &q2)
Return the dot (inner) product of two quaternions.
Definition: quath.h:263
GF_API GfQuath GfSlerp(double alpha, const GfQuath &q0, const GfQuath &q1)
void SetReal(GfHalf real)
Set the real coefficient.
Definition: quath.h:92
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:74
GfQuath GetNormalized(GfHalf eps=GF_MIN_VECTOR_LENGTH) const
Definition: quath.h:113
Definition: quatd.h:42
GF_API GfQuath & operator*=(const GfQuath &q)
Post-multiply quaternion q into this quaternion.
GfHalf ScalarType
Definition: quath.h:46
Definition: vec3h.h:46
GfVec3h & Set(GfHalf s0, GfHalf s1, GfHalf s2)
Set all elements with passed arguments.
Definition: vec3h.h:113
#define GF_MIN_VECTOR_LENGTH
Definition: limits.h:17
#define GF_API
Definition: api.h:23
GfQuath & operator+=(const GfQuath &q)
Add quaternion q to this quaternion.
Definition: quath.h:189