diff --git a/doc/api/a00004_source.html b/doc/api/a00004_source.html index dbbb7273..ac4213a6 100644 --- a/doc/api/a00004_source.html +++ b/doc/api/a00004_source.html @@ -167,7 +167,7 @@
120  _swizzle_base2& operator= (const VecType& that)
121  {
122  struct op {
-
123  void operator() (value_type& e, value_type& t) { e = t; }
+
123  void operator() (value_type& e, value_type& t) { e = t; }
124  };
125  _apply_op(that, op());
126  return *this;
@@ -176,7 +176,7 @@
129  void operator -= (const VecType& that)
130  {
131  struct op {
-
132  void operator() (value_type& e, value_type& t) { e -= t; }
+
132  void operator() (value_type& e, value_type& t) { e -= t; }
133  };
134  _apply_op(that, op());
135  }
@@ -184,7 +184,7 @@
137  void operator += (const VecType& that)
138  {
139  struct op {
-
140  void operator() (value_type& e, value_type& t) { e += t; }
+
140  void operator() (value_type& e, value_type& t) { e += t; }
141  };
142  _apply_op(that, op());
143  }
@@ -192,7 +192,7 @@
145  void operator *= (const VecType& that)
146  {
147  struct op {
-
148  void operator() (value_type& e, value_type& t) { e *= t; }
+
148  void operator() (value_type& e, value_type& t) { e *= t; }
149  };
150  _apply_op(that, op());
151  }
@@ -200,7 +200,7 @@
153  void operator /= (const VecType& that)
154  {
155  struct op {
-
156  void operator() (value_type& e, value_type& t) { e /= t; }
+
156  void operator() (value_type& e, value_type& t) { e /= t; }
157  };
158  _apply_op(that, op());
159  }
diff --git a/doc/api/a00013.html b/doc/api/a00013.html index 97d6ced0..1054a4b8 100644 --- a/doc/api/a00013.html +++ b/doc/api/a00013.html @@ -366,10 +366,9 @@ template<typename T > GLM_FUNC_QUALIFIER
detail::tvec4< T > saturate (const detail::tvec4< T > &x)   - -template<typename T > -GLM_FUNC_QUALIFIER T slerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) -  +template<typename T > +detail::tquat< T > slerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) + 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

diff --git a/doc/api/a00013_source.html b/doc/api/a00013_source.html index 60e50bcc..fd2f72cf 100644 --- a/doc/api/a00013_source.html +++ b/doc/api/a00013_source.html @@ -107,15 +107,15 @@
60 namespace glm
61 {
64 
-
65  template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
-
66  template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}
-
67  template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}
-
68  template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}
-
69  template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}
-
70  template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}
-
71  template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}
+
65  template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}
+
66  template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}
+
67  template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}
+
68  template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}
+
69  template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}
+
70  template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}
+
71  template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}
72 
-
73  template <typename T> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T> const & x, detail::tquat<T> const & y, T const & a){return mix(x, y, a);}
+
73  template <typename T> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T> const & x, detail::tquat<T> const & y, T const & a){return mix(x, y, a);}
74 
75  template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}
76  template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));}
diff --git a/doc/api/a00015.html b/doc/api/a00015.html index a2ad98e0..30145b17 100644 --- a/doc/api/a00015.html +++ b/doc/api/a00015.html @@ -52,81 +52,81 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Functions

template<typename T >
GLM_CONSTEXPR T e ()
 
template<typename T >
GLM_CONSTEXPR T epsilon ()
 
template<typename T >
GLM_CONSTEXPR T euler ()
 
template<typename T >
GLM_CONSTEXPR T golden_ratio ()
 
template<typename T >
GLM_CONSTEXPR T half_pi ()
 
template<typename T >
GLM_CONSTEXPR T ln_ln_two ()
 
template<typename T >
GLM_CONSTEXPR T ln_ten ()
 
template<typename T >
GLM_CONSTEXPR T ln_two ()
 
template<typename T >
GLM_CONSTEXPR T one ()
 
template<typename T >
GLM_CONSTEXPR T one_over_pi ()
 
template<typename T >
GLM_CONSTEXPR T one_over_root_two ()
 
template<typename T >
GLM_CONSTEXPR T pi ()
 
template<typename T >
GLM_CONSTEXPR T quarter_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_five ()
 
template<typename T >
GLM_CONSTEXPR T root_half_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_ln_four ()
 
template<typename T >
GLM_CONSTEXPR T root_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_three ()
 
template<typename T >
GLM_CONSTEXPR T root_two ()
 
template<typename T >
GLM_CONSTEXPR T root_two_pi ()
 
template<typename T >
GLM_CONSTEXPR T third ()
 
template<typename T >
GLM_CONSTEXPR T two_over_pi ()
 
template<typename T >
GLM_CONSTEXPR T two_over_root_pi ()
 
template<typename T >
GLM_CONSTEXPR T two_thirds ()
 
template<typename T >
GLM_CONSTEXPR T zero ()
 
template<typename genType >
genType e ()
 
template<typename genType >
genType epsilon ()
 
template<typename genType >
genType euler ()
 
template<typename genType >
genType golden_ratio ()
 
template<typename genType >
genType half_pi ()
 
template<typename genType >
genType ln_ln_two ()
 
template<typename genType >
genType ln_ten ()
 
template<typename genType >
genType ln_two ()
 
template<typename genType >
genType one ()
 
template<typename genType >
genType one_over_pi ()
 
template<typename genType >
genType one_over_root_two ()
 
template<typename genType >
genType pi ()
 
template<typename genType >
genType quarter_pi ()
 
template<typename genType >
genType root_five ()
 
template<typename genType >
genType root_half_pi ()
 
template<typename genType >
genType root_ln_four ()
 
template<typename genType >
genType root_pi ()
 
template<typename genType >
genType root_three ()
 
template<typename genType >
genType root_two ()
 
template<typename genType >
genType root_two_pi ()
 
template<typename genType >
genType third ()
 
template<typename genType >
genType two_over_pi ()
 
template<typename genType >
genType two_over_root_pi ()
 
template<typename genType >
genType two_thirds ()
 
template<typename genType >
genType zero ()
 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

diff --git a/doc/api/a00015_source.html b/doc/api/a00015_source.html index baedf1ca..0934f8e6 100644 --- a/doc/api/a00015_source.html +++ b/doc/api/a00015_source.html @@ -97,80 +97,80 @@
50 namespace glm
51 {
54 
-
58  template <typename T>
-
59  GLM_CONSTEXPR T epsilon();
+
58  template <typename genType>
+
59  genType epsilon();
60 
-
63  template <typename T>
-
64  GLM_CONSTEXPR T zero();
+
63  template <typename genType>
+
64  genType zero();
65 
-
68  template <typename T>
-
69  GLM_CONSTEXPR T one();
+
68  template <typename genType>
+
69  genType one();
70 
-
73  template <typename T>
-
74  GLM_CONSTEXPR T pi();
+
73  template <typename genType>
+
74  genType pi();
75 
-
78  template <typename T>
-
79  GLM_CONSTEXPR T root_pi();
+
78  template <typename genType>
+
79  genType root_pi();
80 
-
83  template <typename T>
-
84  GLM_CONSTEXPR T half_pi();
+
83  template <typename genType>
+
84  genType half_pi();
85 
-
88  template <typename T>
-
89  GLM_CONSTEXPR T quarter_pi();
+
88  template <typename genType>
+
89  genType quarter_pi();
90 
-
93  template <typename T>
-
94  GLM_CONSTEXPR T one_over_pi();
+
93  template <typename genType>
+
94  genType one_over_pi();
95 
-
98  template <typename T>
-
99  GLM_CONSTEXPR T two_over_pi();
+
98  template <typename genType>
+
99  genType two_over_pi();
100 
-
103  template <typename T>
-
104  GLM_CONSTEXPR T two_over_root_pi();
+
103  template <typename genType>
+
104  genType two_over_root_pi();
105 
-
108  template <typename T>
-
109  GLM_CONSTEXPR T one_over_root_two();
+
108  template <typename genType>
+
109  genType one_over_root_two();
110 
-
113  template <typename T>
-
114  GLM_CONSTEXPR T root_half_pi();
+
113  template <typename genType>
+
114  genType root_half_pi();
115 
-
118  template <typename T>
-
119  GLM_CONSTEXPR T root_two_pi();
+
118  template <typename genType>
+
119  genType root_two_pi();
120 
-
123  template <typename T>
-
124  GLM_CONSTEXPR T root_ln_four();
+
123  template <typename genType>
+
124  genType root_ln_four();
125 
-
128  template <typename T>
-
129  GLM_CONSTEXPR T e();
+
128  template <typename genType>
+
129  genType e();
130 
-
133  template <typename T>
-
134  GLM_CONSTEXPR T euler();
+
133  template <typename genType>
+
134  genType euler();
135 
-
138  template <typename T>
-
139  GLM_CONSTEXPR T root_two();
+
138  template <typename genType>
+
139  genType root_two();
140 
-
143  template <typename T>
-
144  GLM_CONSTEXPR T root_three();
+
143  template <typename genType>
+
144  genType root_three();
145 
-
148  template <typename T>
-
149  GLM_CONSTEXPR T root_five();
+
148  template <typename genType>
+
149  genType root_five();
150 
-
153  template <typename T>
-
154  GLM_CONSTEXPR T ln_two();
+
153  template <typename genType>
+
154  genType ln_two();
155 
-
158  template <typename T>
-
159  GLM_CONSTEXPR T ln_ten();
+
158  template <typename genType>
+
159  genType ln_ten();
160 
-
163  template <typename T>
-
164  GLM_CONSTEXPR T ln_ln_two();
+
163  template <typename genType>
+
164  genType ln_ln_two();
165 
-
168  template <typename T>
-
169  GLM_CONSTEXPR T third();
+
168  template <typename genType>
+
169  genType third();
170 
-
173  template <typename T>
-
174  GLM_CONSTEXPR T two_thirds();
+
173  template <typename genType>
+
174  genType two_thirds();
175 
-
178  template <typename T>
-
179  GLM_CONSTEXPR T golden_ratio();
+
178  template <typename genType>
+
179  genType golden_ratio();
180 
182 } //namespace glm
183 
diff --git a/doc/api/a00017_source.html b/doc/api/a00017_source.html index e625d199..f1558625 100644 --- a/doc/api/a00017_source.html +++ b/doc/api/a00017_source.html @@ -100,28 +100,28 @@
53 {
56 
59  template <typename genType>
-
60  typename genType::boolType epsilonEqual(
-
61  genType const & x,
-
62  genType const & y,
-
63  typename genType::value_type const & epsilon);
-
64 
+
60  typename genType::boolType epsilonEqual(
+
61  genType const & x,
+
62  genType const & y,
+
63  typename genType::value_type const & epsilon);
+
64 
67  template <typename genType>
68  typename genType::boolType epsilonEqual(
69  genType const & x,
70  genType const & y,
-
71  genType const & epsilon);
+
71  genType const & epsilon);
72 
75  template <typename genType>
-
76  typename genType::boolType epsilonNotEqual(
-
77  genType const & x,
-
78  genType const & y,
-
79  typename genType::value_type const & epsilon);
-
80 
+
76  typename genType::boolType epsilonNotEqual(
+
77  genType const & x,
+
78  genType const & y,
+
79  typename genType::value_type const & epsilon);
+
80 
83  template <typename genType>
84  typename genType::boolType epsilonNotEqual(
85  genType const & x,
86  genType const & y,
-
87  genType const & epsilon);
+
87  genType const & epsilon);
88 
90 }//namespace glm
91 
diff --git a/doc/api/a00019_source.html b/doc/api/a00019_source.html index e8cc9cd3..187b12cc 100644 --- a/doc/api/a00019_source.html +++ b/doc/api/a00019_source.html @@ -141,15 +141,15 @@
114 
117  template <typename valType>
118  detail::tmat4x4<valType> eulerAngleYXZ(
-
119  valType const & yaw,
-
120  valType const & pitch,
-
121  valType const & roll);
+
119  valType const & yaw,
+
120  valType const & pitch,
+
121  valType const & roll);
122 
125  template <typename valType>
126  detail::tmat4x4<valType> yawPitchRoll(
-
127  valType const & yaw,
-
128  valType const & pitch,
-
129  valType const & roll);
+
127  valType const & yaw,
+
128  valType const & pitch,
+
129  valType const & roll);
130 
133  template <typename T>
134  detail::tmat2x2<T> orientate2(T const & angle);
diff --git a/doc/api/a00052_source.html b/doc/api/a00052_source.html index 3b5cf10d..471989b6 100644 --- a/doc/api/a00052_source.html +++ b/doc/api/a00052_source.html @@ -99,7 +99,7 @@
56  genType const & m,
57  int index);
58 
-
61  template <typename genType>
+
61  template <typename genType>
62  genType row(
63  genType const & m,
64  int index,
diff --git a/doc/api/a00059_source.html b/doc/api/a00059_source.html index 0338718a..59145ede 100644 --- a/doc/api/a00059_source.html +++ b/doc/api/a00059_source.html @@ -101,42 +101,42 @@
58  template<typename T>
59  bool isNull(
60  detail::tmat2x2<T> const & m,
-
61  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
+
61  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
62 
65  template<typename T>
66  bool isNull(
67  detail::tmat3x3<T> const & m,
-
68  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
+
68  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
69 
72  template<typename T>
73  bool isNull(
74  detail::tmat4x4<T> const & m,
-
75  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
+
75  T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
76 
79  template<typename genType>
80  bool isIdentity(
81  genType const & m,
-
82  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
82  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
83 
86  template<typename valType>
87  bool isNormalized(
88  detail::tmat2x2<valType> const & m,
-
89  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
+
89  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
90 
93  template<typename valType>
94  bool isNormalized(
95  detail::tmat3x3<valType> const & m,
-
96  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
+
96  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
97 
100  template<typename valType>
101  bool isNormalized(
102  detail::tmat4x4<valType> const & m,
-
103  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
+
103  valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
104 
107  template<typename valType, template <typename> class matType>
108  bool isOrthogonal(
109  matType<valType> const & m,
-
110  valType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
+
110  valType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
111 
113 }//namespace glm
114 
diff --git a/doc/api/a00076.html b/doc/api/a00076.html index 8243cecc..45041cad 100644 --- a/doc/api/a00076.html +++ b/doc/api/a00076.html @@ -100,6 +100,9 @@ Functions template<typename T > T length (detail::tquat< T > const &q)   +template<typename T > +detail::tquat< T > lerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) +  template<typename T > detail::tmat3x3< T > mat3_cast (detail::tquat< T > const &x)   @@ -112,15 +115,27 @@ Functions template<typename T > detail::tquat< T > normalize (detail::tquat< T > const &q)   +template<typename valType > +valType pitch (detail::tquat< valType > const &x) +  template<typename T > detail::tquat< T > quat_cast (detail::tmat3x3< T > const &x)   template<typename T > detail::tquat< T > quat_cast (detail::tmat4x4< T > const &x)   +template<typename valType > +valType roll (detail::tquat< valType > const &x) +  template<typename T > detail::tquat< T > rotate (detail::tquat< T > const &q, typename detail::tquat< T >::value_type const &angle, detail::tvec3< T > const &axis)   +template<typename T > +detail::tquat< T > slerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) +  +template<typename valType > +valType yaw (detail::tquat< valType > const &x) + 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

@@ -128,11 +143,13 @@ Functions

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

GLM_GTC_quaternion

-
Date
2009-05-21 / 2011-06-05
+
Date
2009-05-21 / 2012-12-20
Author
Christophe Riccio
See Also
GLM Core (dependence)
-GLM_GTC_half_float (dependence)
+GLM_GTC_half_float (dependence) +
+GLM_GTC_constants (dependence)

Definition in file gtc/quaternion.hpp.

diff --git a/doc/api/a00076_source.html b/doc/api/a00076_source.html index 38ea8e01..51964b92 100644 --- a/doc/api/a00076_source.html +++ b/doc/api/a00076_source.html @@ -83,206 +83,232 @@
36 
37 
38 
-
39 #ifndef GLM_GTC_quaternion
-
40 #define GLM_GTC_quaternion GLM_VERSION
-
41 
-
42 // Dependency:
-
43 #include "../glm.hpp"
-
44 #include "../gtc/half_float.hpp"
-
45 
-
46 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
-
47 # pragma message("GLM: GLM_GTC_quaternion extension included")
-
48 #endif
-
49 
-
50 namespace glm{
-
51 namespace detail
-
52 {
-
53  template <typename T>
-
54  struct tquat// : public genType<T, tquat>
-
55  {
-
56  enum ctor{null};
-
57 
-
58  typedef T value_type;
-
59  typedef std::size_t size_type;
-
60 
-
61  public:
-
62  value_type x, y, z, w;
-
63 
-
64  GLM_FUNC_DECL size_type length() const;
+
39 
+
40 #ifndef GLM_GTC_quaternion
+
41 #define GLM_GTC_quaternion GLM_VERSION
+
42 
+
43 // Dependency:
+
44 #include "../glm.hpp"
+
45 #include "../gtc/half_float.hpp"
+
46 #include "../gtc/constants.hpp"
+
47 
+
48 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
+
49 # pragma message("GLM: GLM_GTC_quaternion extension included")
+
50 #endif
+
51 
+
52 namespace glm{
+
53 namespace detail
+
54 {
+
55  template <typename T>
+
56  struct tquat// : public genType<T, tquat>
+
57  {
+
58  enum ctor{null};
+
59 
+
60  typedef T value_type;
+
61  typedef std::size_t size_type;
+
62 
+
63  public:
+
64  value_type x, y, z, w;
65 
-
66  // Constructors
-
67  tquat();
-
68  explicit tquat(
-
69  value_type const & s,
-
70  glm::detail::tvec3<T> const & v);
-
71  explicit tquat(
-
72  value_type const & w,
-
73  value_type const & x,
-
74  value_type const & y,
-
75  value_type const & z);
-
76 
-
77  // Convertions
+
66  GLM_FUNC_DECL size_type length() const;
+
67 
+
68  // Constructors
+
69  tquat();
+
70  explicit tquat(
+
71  value_type const & s,
+
72  glm::detail::tvec3<T> const & v);
+
73  explicit tquat(
+
74  value_type const & w,
+
75  value_type const & x,
+
76  value_type const & y,
+
77  value_type const & z);
78 
-
80  explicit tquat(
-
81  tvec3<T> const & eulerAngles);
+
79  // Convertions
+
80 
82  explicit tquat(
-
83  tmat3x3<T> const & m);
+
83  tvec3<T> const & eulerAngles);
84  explicit tquat(
-
85  tmat4x4<T> const & m);
-
86 
-
87  // Accesses
-
88  value_type & operator[](int i);
-
89  value_type const & operator[](int i) const;
-
90 
-
91  // Operators
-
92  tquat<T> & operator*=(value_type const & s);
-
93  tquat<T> & operator/=(value_type const & s);
-
94  };
-
95 
-
96  template <typename T>
-
97  detail::tquat<T> operator- (
-
98  detail::tquat<T> const & q);
-
99 
-
100  template <typename T>
-
101  detail::tquat<T> operator+ (
-
102  detail::tquat<T> const & q,
-
103  detail::tquat<T> const & p);
-
104 
-
105  template <typename T>
-
106  detail::tquat<T> operator* (
-
107  detail::tquat<T> const & q,
-
108  detail::tquat<T> const & p);
-
109 
-
110  template <typename T>
-
111  detail::tvec3<T> operator* (
-
112  detail::tquat<T> const & q,
-
113  detail::tvec3<T> const & v);
-
114 
-
115  template <typename T>
-
116  detail::tvec3<T> operator* (
-
117  detail::tvec3<T> const & v,
-
118  detail::tquat<T> const & q);
-
119 
-
120  template <typename T>
-
121  detail::tvec4<T> operator* (
-
122  detail::tquat<T> const & q,
-
123  detail::tvec4<T> const & v);
-
124 
-
125  template <typename T>
-
126  detail::tvec4<T> operator* (
-
127  detail::tvec4<T> const & v,
-
128  detail::tquat<T> const & q);
-
129 
-
130  template <typename T>
-
131  detail::tquat<T> operator* (
-
132  detail::tquat<T> const & q,
-
133  typename detail::tquat<T>::value_type const & s);
-
134 
-
135  template <typename T>
-
136  detail::tquat<T> operator* (
-
137  typename detail::tquat<T>::value_type const & s,
-
138  detail::tquat<T> const & q);
-
139 
-
140  template <typename T>
-
141  detail::tquat<T> operator/ (
-
142  detail::tquat<T> const & q,
-
143  typename detail::tquat<T>::value_type const & s);
-
144 
-
145 } //namespace detail
+
85  tmat3x3<T> const & m);
+
86  explicit tquat(
+
87  tmat4x4<T> const & m);
+
88 
+
89  // Accesses
+
90  value_type & operator[](int i);
+
91  value_type const & operator[](int i) const;
+
92 
+
93  // Operators
+
94  tquat<T> & operator*=(value_type const & s);
+
95  tquat<T> & operator/=(value_type const & s);
+
96  };
+
97 
+
98  template <typename T>
+
99  detail::tquat<T> operator- (
+
100  detail::tquat<T> const & q);
+
101 
+
102  template <typename T>
+
103  detail::tquat<T> operator+ (
+
104  detail::tquat<T> const & q,
+
105  detail::tquat<T> const & p);
+
106 
+
107  template <typename T>
+
108  detail::tquat<T> operator* (
+
109  detail::tquat<T> const & q,
+
110  detail::tquat<T> const & p);
+
111 
+
112  template <typename T>
+
113  detail::tvec3<T> operator* (
+
114  detail::tquat<T> const & q,
+
115  detail::tvec3<T> const & v);
+
116 
+
117  template <typename T>
+
118  detail::tvec3<T> operator* (
+
119  detail::tvec3<T> const & v,
+
120  detail::tquat<T> const & q);
+
121 
+
122  template <typename T>
+
123  detail::tvec4<T> operator* (
+
124  detail::tquat<T> const & q,
+
125  detail::tvec4<T> const & v);
+
126 
+
127  template <typename T>
+
128  detail::tvec4<T> operator* (
+
129  detail::tvec4<T> const & v,
+
130  detail::tquat<T> const & q);
+
131 
+
132  template <typename T>
+
133  detail::tquat<T> operator* (
+
134  detail::tquat<T> const & q,
+
135  typename detail::tquat<T>::value_type const & s);
+
136 
+
137  template <typename T>
+
138  detail::tquat<T> operator* (
+
139  typename detail::tquat<T>::value_type const & s,
+
140  detail::tquat<T> const & q);
+
141 
+
142  template <typename T>
+
143  detail::tquat<T> operator/ (
+
144  detail::tquat<T> const & q,
+
145  typename detail::tquat<T>::value_type const & s);
146 
-
149 
-
153  template <typename T>
-
154  T length(
-
155  detail::tquat<T> const & q);
-
156 
-
160  template <typename T>
-
161  detail::tquat<T> normalize(
-
162  detail::tquat<T> const & q);
-
163 
-
167  template <typename T>
-
168  T dot(
-
169  detail::tquat<T> const & q1,
-
170  detail::tquat<T> const & q2);
-
171 
-
175  template <typename T>
-
176  detail::tquat<T> mix(
-
177  detail::tquat<T> const & x,
-
178  detail::tquat<T> const & y,
-
179  T const & a);
-
180 
+
147 } //namespace detail
+
148 
+
151 
+
155  template <typename T>
+
156  T length(
+
157  detail::tquat<T> const & q);
+
158 
+
162  template <typename T>
+
163  detail::tquat<T> normalize(
+
164  detail::tquat<T> const & q);
+
165 
+
169  template <typename T>
+
170  T dot(
+
171  detail::tquat<T> const & q1,
+
172  detail::tquat<T> const & q2);
+
173 
184  template <typename T>
-
185  detail::tquat<T> conjugate(
-
186  detail::tquat<T> const & q);
-
187 
-
191  template <typename T>
-
192  detail::tquat<T> inverse(
-
193  detail::tquat<T> const & q);
-
194 
-
202  template <typename T>
-
203  detail::tquat<T> rotate(
-
204  detail::tquat<T> const & q,
-
205  typename detail::tquat<T>::value_type const & angle,
-
206  detail::tvec3<T> const & axis);
-
207 
-
211  template <typename T>
-
212  detail::tvec3<T> eulerAngles(
-
213  detail::tquat<T> const & x);
-
214 
-
218  template <typename T>
-
219  detail::tmat3x3<T> mat3_cast(
-
220  detail::tquat<T> const & x);
-
221 
-
225  template <typename T>
-
226  detail::tmat4x4<T> mat4_cast(
-
227  detail::tquat<T> const & x);
-
228 
-
232  template <typename T>
-
233  detail::tquat<T> quat_cast(
-
234  detail::tmat3x3<T> const & x);
-
235 
+
185  detail::tquat<T> mix(
+
186  detail::tquat<T> const & x,
+
187  detail::tquat<T> const & y,
+
188  T const & a);
+
189 
+
198  template <typename T>
+
199  detail::tquat<T> lerp(
+
200  detail::tquat<T> const & x,
+
201  detail::tquat<T> const & y,
+
202  T const & a);
+
203 
+
212  template <typename T>
+
213  detail::tquat<T> slerp(
+
214  detail::tquat<T> const & x,
+
215  detail::tquat<T> const & y,
+
216  T const & a);
+
217 
+
221  template <typename T>
+
222  detail::tquat<T> conjugate(
+
223  detail::tquat<T> const & q);
+
224 
+
228  template <typename T>
+
229  detail::tquat<T> inverse(
+
230  detail::tquat<T> const & q);
+
231 
239  template <typename T>
-
240  detail::tquat<T> quat_cast(
-
241  detail::tmat4x4<T> const & x);
-
242 
-
246  template <typename valType>
-
247  valType angle(
-
248  detail::tquat<valType> const & x);
-
249 
-
253  template <typename valType>
-
254  detail::tvec3<valType> axis(
-
255  detail::tquat<valType> const & x);
-
256 
-
265  template <typename valType>
-
266  detail::tquat<valType> angleAxis(
-
267  valType const & angle,
-
268  valType const & x,
-
269  valType const & y,
-
270  valType const & z);
-
271 
-
278  template <typename valType>
-
279  detail::tquat<valType> angleAxis(
-
280  valType const & angle,
-
281  detail::tvec3<valType> const & axis);
-
282 
-
286  typedef detail::tquat<float> quat;
-
287 
-
291  typedef detail::tquat<detail::half> hquat;
-
292 
-
296  typedef detail::tquat<float> fquat;
-
297 
-
301  typedef detail::tquat<double> dquat;
-
302 
-
306  typedef detail::tquat<lowp_float> lowp_quat;
+
240  detail::tquat<T> rotate(
+
241  detail::tquat<T> const & q,
+
242  typename detail::tquat<T>::value_type const & angle,
+
243  detail::tvec3<T> const & axis);
+
244 
+
248  template <typename T>
+
249  detail::tvec3<T> eulerAngles(
+
250  detail::tquat<T> const & x);
+
251 
+
255  template <typename valType>
+
256  valType roll(
+
257  detail::tquat<valType> const & x);
+
258 
+
262  template <typename valType>
+
263  valType pitch(
+
264  detail::tquat<valType> const & x);
+
265 
+
269  template <typename valType>
+
270  valType yaw(
+
271  detail::tquat<valType> const & x);
+
272 
+
276  template <typename T>
+
277  detail::tmat3x3<T> mat3_cast(
+
278  detail::tquat<T> const & x);
+
279 
+
283  template <typename T>
+
284  detail::tmat4x4<T> mat4_cast(
+
285  detail::tquat<T> const & x);
+
286 
+
290  template <typename T>
+
291  detail::tquat<T> quat_cast(
+
292  detail::tmat3x3<T> const & x);
+
293 
+
297  template <typename T>
+
298  detail::tquat<T> quat_cast(
+
299  detail::tmat4x4<T> const & x);
+
300 
+
304  template <typename valType>
+
305  valType angle(
+
306  detail::tquat<valType> const & x);
307 
-
311  typedef detail::tquat<mediump_float> mediump_quat;
-
312 
-
316  typedef detail::tquat<highp_float> highp_quat;
-
317 
-
319 } //namespace glm
-
320 
-
321 #include "quaternion.inl"
-
322 
-
323 #endif//GLM_GTC_quaternion
+
311  template <typename valType>
+
312  detail::tvec3<valType> axis(
+
313  detail::tquat<valType> const & x);
+
314 
+
323  template <typename valType>
+
324  detail::tquat<valType> angleAxis(
+
325  valType const & angle,
+
326  valType const & x,
+
327  valType const & y,
+
328  valType const & z);
+
329 
+
336  template <typename valType>
+
337  detail::tquat<valType> angleAxis(
+
338  valType const & angle,
+
339  detail::tvec3<valType> const & axis);
+
340 
+
344  typedef detail::tquat<float> quat;
+
345 
+
349  typedef detail::tquat<detail::half> hquat;
+
350 
+
354  typedef detail::tquat<float> fquat;
+
355 
+
359  typedef detail::tquat<double> dquat;
+
360 
+
364  typedef detail::tquat<lowp_float> lowp_quat;
+
365 
+
369  typedef detail::tquat<mediump_float> mediump_quat;
+
370 
+
374  typedef detail::tquat<highp_float> highp_quat;
+
375 
+
377 } //namespace glm
+
378 
+
379 #include "quaternion.inl"
+
380 
+
381 #endif//GLM_GTC_quaternion
diff --git a/doc/api/a00077.html b/doc/api/a00077.html index f965b773..9c3e4f16 100644 --- a/doc/api/a00077.html +++ b/doc/api/a00077.html @@ -58,9 +58,6 @@ Functions template<typename valType > detail::tvec3< valType > cross (detail::tvec3< valType > const &v, detail::tquat< valType > const &q)   -template<typename valType > -detail::tvec3< valType > eulerAngles (detail::tquat< valType > const &x) -  template<typename valType > detail::tquat< valType > exp (detail::tquat< valType > const &q, valType const &exponent)   @@ -76,15 +73,9 @@ Functions template<typename valType > detail::tquat< valType > log (detail::tquat< valType > const &q)   -template<typename valType > -valType pitch (detail::tquat< valType > const &x) -  template<typename valType > detail::tquat< valType > pow (detail::tquat< valType > const &x, valType const &y)   -template<typename valType > -valType roll (detail::tquat< valType > const &x) -  template<typename valType > detail::tvec3< valType > rotate (detail::tquat< valType > const &q, detail::tvec3< valType > const &v)   @@ -109,9 +100,6 @@ Functions template<typename valType > detail::tquat< valType > toQuat (detail::tmat4x4< valType > const &x)   -template<typename valType > -valType yaw (detail::tquat< valType > const &x) - 

Detailed Description

OpenGL Mathematics (glm.g-truc.net)

diff --git a/doc/api/a00077_source.html b/doc/api/a00077_source.html index 43678f17..30121442 100644 --- a/doc/api/a00077_source.html +++ b/doc/api/a00077_source.html @@ -154,54 +154,38 @@
143  detail::tquat<valType> const & q);
144 
148  template <typename valType>
-
149  valType roll(
-
150  detail::tquat<valType> const & x);
+
149  detail::tmat3x3<valType> toMat3(
+
150  detail::tquat<valType> const & x){return mat3_cast(x);}
151 
-
155  template <typename valType>
-
156  valType pitch(
-
157  detail::tquat<valType> const & x);
+
155  template <typename valType>
+
156  detail::tmat4x4<valType> toMat4(
+
157  detail::tquat<valType> const & x){return mat4_cast(x);}
158 
162  template <typename valType>
-
163  valType yaw(
-
164  detail::tquat<valType> const & x);
+
163  detail::tquat<valType> toQuat(
+
164  detail::tmat3x3<valType> const & x){return quat_cast(x);}
165 
169  template <typename valType>
-
170  detail::tvec3<valType> eulerAngles(
-
171  detail::tquat<valType> const & x);
+
170  detail::tquat<valType> toQuat(
+
171  detail::tmat4x4<valType> const & x){return quat_cast(x);}
172 
-
176  template <typename valType>
-
177  detail::tmat3x3<valType> toMat3(
-
178  detail::tquat<valType> const & x){return mat3_cast(x);}
-
179 
-
183  template <typename valType>
-
184  detail::tmat4x4<valType> toMat4(
-
185  detail::tquat<valType> const & x){return mat4_cast(x);}
-
186 
-
190  template <typename valType>
-
191  detail::tquat<valType> toQuat(
-
192  detail::tmat3x3<valType> const & x){return quat_cast(x);}
+
176  template <typename T>
+
177  detail::tquat<T> shortMix(
+
178  detail::tquat<T> const & x,
+
179  detail::tquat<T> const & y,
+
180  T const & a);
+
181 
+
185  template <typename T>
+
186  detail::tquat<T> fastMix(
+
187  detail::tquat<T> const & x,
+
188  detail::tquat<T> const & y,
+
189  T const & a);
+
190 
+
192 }//namespace glm
193 
-
197  template <typename valType>
-
198  detail::tquat<valType> toQuat(
-
199  detail::tmat4x4<valType> const & x){return quat_cast(x);}
-
200 
-
204  template <typename T>
-
205  detail::tquat<T> shortMix(
-
206  detail::tquat<T> const & x,
-
207  detail::tquat<T> const & y,
-
208  T const & a);
-
209 
-
213  template <typename T>
-
214  detail::tquat<T> fastMix(
-
215  detail::tquat<T> const & x,
-
216  detail::tquat<T> const & y,
-
217  T const & a);
-
218 
-
220 }//namespace glm
-
221 
-
222 #include "quaternion.inl"
-
223 
-
224 #endif//GLM_GTX_quaternion
+
194 #include "quaternion.inl"
+
195 
+
196 #endif//GLM_GTX_quaternion
diff --git a/doc/api/a00084_source.html b/doc/api/a00084_source.html index ee2abb59..a7a4a972 100644 --- a/doc/api/a00084_source.html +++ b/doc/api/a00084_source.html @@ -577,151 +577,158 @@
536 # define GLM_ARCH GLM_ARCH_PURE
537 #endif
538 
-
539 //#if(GLM_ARCH != GLM_ARCH_PURE)
-
540 #if(GLM_ARCH & GLM_ARCH_AVX2)
-
541 # include <immintrin.h>
-
542 #endif//GLM_ARCH
-
543 #if(GLM_ARCH & GLM_ARCH_AVX)
-
544 # include <immintrin.h>
-
545 #endif//GLM_ARCH
-
546 #if(GLM_ARCH & GLM_ARCH_SSE4)
-
547 # include <smmintrin.h>
-
548 #endif//GLM_ARCH
-
549 #if(GLM_ARCH & GLM_ARCH_SSE3)
-
550 # include <pmmintrin.h>
-
551 #endif//GLM_ARCH
-
552 #if(GLM_ARCH & GLM_ARCH_SSE2)
-
553 # include <emmintrin.h>
-
554 #endif//GLM_ARCH
-
555 //#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
556 
-
557 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED))
-
558 # define GLM_MESSAGE_ARCH_DISPLAYED
-
559 # if(GLM_ARCH == GLM_ARCH_PURE)
-
560 # pragma message("GLM: Platform independent")
-
561 # elif(GLM_ARCH & GLM_ARCH_SSE2)
-
562 # pragma message("GLM: SSE2 instruction set")
-
563 # elif(GLM_ARCH & GLM_ARCH_SSE3)
-
564 # pragma message("GLM: SSE3 instruction set")
-
565 # elif(GLM_ARCH & GLM_ARCH_SSE4)
-
566 # pragma message("GLM: SSE4 instruction set")
-
567 # elif(GLM_ARCH & GLM_ARCH_AVX)
-
568 # pragma message("GLM: AVX instruction set")
-
569 # elif(GLM_ARCH & GLM_ARCH_AVX2)
-
570 # pragma message("GLM: AVX2 instruction set")
-
571 # endif//GLM_ARCH
-
572 #endif//GLM_MESSAGE
-
573 
-
575 // Support check macros
-
576 
-
577 #define GLM_SUPPORT_ANONYMOUS_UNION() \
-
578  ((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98)
-
579 
-
580 //#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() <backslash>
-
581 // (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))
-
582 
-
583 #define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
-
584  (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS)) || ((GLM_LANG == GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
-
585 
-
586 #define GLM_SUPPORT_SWIZZLE_OPERATOR() \
-
587  (/*defined(GLM_SWIZZLE) && */GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
-
588 
-
589 #define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
-
590 
-
592 // Components
-
593 
-
594 //#define GLM_FORCE_ONLY_XYZW
-
595 #define GLM_COMPONENT_ONLY_XYZW 0 // To disable multiple vector component names access.
-
596 #define GLM_COMPONENT_CXX98 1 //
-
597 #define GLM_COMPONENT_CXX11 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
-
598 
-
599 #if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
-
600 # define GLM_COMPONENT GLM_COMPONENT_CXX11
-
601 #elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
-
602 # define GLM_COMPONENT GLM_COMPONENT_CXX98
-
603 #else
-
604 # define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
-
605 #endif
-
606 
-
607 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
-
608 # define GLM_MESSAGE_COMPONENT_DISPLAYED
-
609 # if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-
610 # pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
-
611 # elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-
612 # pragma message("GLM: x,y,z,w component names for all vector types")
-
613 # elif(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-
614 # pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
-
615 # else
-
616 # error "GLM: GLM_COMPONENT value unknown"
-
617 # endif//GLM_MESSAGE_COMPONENT_DISPLAYED
-
618 #endif//GLM_MESSAGE
-
619 
-
621 // Radians
-
622 
-
623 //#define GLM_FORCE_RADIANS
-
624 
-
626 // Static assert
-
627 
-
628 #if(GLM_LANG == GLM_LANG_CXX0X)
-
629 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
-
630 #elif(defined(BOOST_STATIC_ASSERT))
-
631 # define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
-
632 #elif(GLM_COMPILER & GLM_COMPILER_VC)
-
633 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
-
634 #else
-
635 # define GLM_STATIC_ASSERT(x, message)
-
636 # define GLM_STATIC_ASSERT_NULL
-
637 #endif//GLM_LANG
-
638 
-
640 // Qualifiers
-
641 
-
642 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
-
643 
-
644 #if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
-
645 # define GLM_CUDA_FUNC_DEF __device__ __host__
-
646 # define GLM_CUDA_FUNC_DECL __device__ __host__
-
647 #else
-
648 # define GLM_CUDA_FUNC_DEF
-
649 # define GLM_CUDA_FUNC_DECL
-
650 #endif
-
651 
-
652 #if GLM_COMPILER & GLM_COMPILER_GCC
-
653 #define GLM_VAR_USED __attribute__ ((unused))
+
539 // With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is
+
540 // that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems.
+
541 // To fix, we just explicitly include intrin.h here.
+
542 #if defined(__MINGW32__) && (GLM_ARCH != GLM_ARCH_PURE)
+
543 # include <intrin.h>
+
544 #endif
+
545 
+
546 //#if(GLM_ARCH != GLM_ARCH_PURE)
+
547 #if(GLM_ARCH & GLM_ARCH_AVX2)
+
548 # include <immintrin.h>
+
549 #endif//GLM_ARCH
+
550 #if(GLM_ARCH & GLM_ARCH_AVX)
+
551 # include <immintrin.h>
+
552 #endif//GLM_ARCH
+
553 #if(GLM_ARCH & GLM_ARCH_SSE4)
+
554 # include <smmintrin.h>
+
555 #endif//GLM_ARCH
+
556 #if(GLM_ARCH & GLM_ARCH_SSE3)
+
557 # include <pmmintrin.h>
+
558 #endif//GLM_ARCH
+
559 #if(GLM_ARCH & GLM_ARCH_SSE2)
+
560 # include <emmintrin.h>
+
561 #endif//GLM_ARCH
+
562 //#endif//(GLM_ARCH != GLM_ARCH_PURE)
+
563 
+
564 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED))
+
565 # define GLM_MESSAGE_ARCH_DISPLAYED
+
566 # if(GLM_ARCH == GLM_ARCH_PURE)
+
567 # pragma message("GLM: Platform independent")
+
568 # elif(GLM_ARCH & GLM_ARCH_SSE2)
+
569 # pragma message("GLM: SSE2 instruction set")
+
570 # elif(GLM_ARCH & GLM_ARCH_SSE3)
+
571 # pragma message("GLM: SSE3 instruction set")
+
572 # elif(GLM_ARCH & GLM_ARCH_SSE4)
+
573 # pragma message("GLM: SSE4 instruction set")
+
574 # elif(GLM_ARCH & GLM_ARCH_AVX)
+
575 # pragma message("GLM: AVX instruction set")
+
576 # elif(GLM_ARCH & GLM_ARCH_AVX2)
+
577 # pragma message("GLM: AVX2 instruction set")
+
578 # endif//GLM_ARCH
+
579 #endif//GLM_MESSAGE
+
580 
+
582 // Support check macros
+
583 
+
584 #define GLM_SUPPORT_ANONYMOUS_UNION() \
+
585  ((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98)
+
586 
+
587 //#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() <backslash>
+
588 // (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))
+
589 
+
590 #define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
+
591  (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS)) || ((GLM_LANG == GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
+
592 
+
593 #define GLM_SUPPORT_SWIZZLE_OPERATOR() \
+
594  (/*defined(GLM_SWIZZLE) && */GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
+
595 
+
596 #define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
+
597 
+
599 // Components
+
600 
+
601 //#define GLM_FORCE_ONLY_XYZW
+
602 #define GLM_COMPONENT_ONLY_XYZW 0 // To disable multiple vector component names access.
+
603 #define GLM_COMPONENT_CXX98 1 //
+
604 #define GLM_COMPONENT_CXX11 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
+
605 
+
606 #if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
+
607 # define GLM_COMPONENT GLM_COMPONENT_CXX11
+
608 #elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
+
609 # define GLM_COMPONENT GLM_COMPONENT_CXX98
+
610 #else
+
611 # define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
+
612 #endif
+
613 
+
614 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
+
615 # define GLM_MESSAGE_COMPONENT_DISPLAYED
+
616 # if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
+
617 # pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
+
618 # elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+
619 # pragma message("GLM: x,y,z,w component names for all vector types")
+
620 # elif(GLM_COMPONENT == GLM_COMPONENT_CXX11)
+
621 # pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
+
622 # else
+
623 # error "GLM: GLM_COMPONENT value unknown"
+
624 # endif//GLM_MESSAGE_COMPONENT_DISPLAYED
+
625 #endif//GLM_MESSAGE
+
626 
+
628 // Radians
+
629 
+
630 //#define GLM_FORCE_RADIANS
+
631 
+
633 // Static assert
+
634 
+
635 #if(GLM_LANG == GLM_LANG_CXX0X)
+
636 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+
637 #elif(defined(BOOST_STATIC_ASSERT))
+
638 # define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
+
639 #elif(GLM_COMPILER & GLM_COMPILER_VC)
+
640 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+
641 #else
+
642 # define GLM_STATIC_ASSERT(x, message)
+
643 # define GLM_STATIC_ASSERT_NULL
+
644 #endif//GLM_LANG
+
645 
+
647 // Qualifiers
+
648 
+
649 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
+
650 
+
651 #if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
+
652 # define GLM_CUDA_FUNC_DEF __device__ __host__
+
653 # define GLM_CUDA_FUNC_DECL __device__ __host__
654 #else
-
655 #define GLM_VAR_USED
-
656 #endif
-
657 
-
658 #if(defined(GLM_FORCE_INLINE))
-
659 # if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-
660 # define GLM_INLINE __forceinline
-
661 # elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
-
662 # define GLM_INLINE __attribute__((always_inline))
-
663 # else
-
664 # define GLM_INLINE inline
-
665 # endif//GLM_COMPILER
-
666 #else
-
667 # define GLM_INLINE inline
-
668 #endif//defined(GLM_FORCE_INLINE)
-
669 
-
670 #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
-
671 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
-
672 
-
674 // Swizzle operators
-
675 
-
676 // User defines: GLM_SWIZZLE
-
677 
-
678 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
-
679 # define GLM_MESSAGE_SWIZZLE_DISPLAYED
-
680 # if(GLM_SUPPORT_SWIZZLE_OPERATOR())
-
681 # pragma message("GLM: Swizzling operators enabled")
-
682 # elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
-
683 # pragma message("GLM: Swizzling operators supported through swizzling functions")
-
684 # else
-
685 # pragma message("GLM: Swizzling operators disabled")
-
686 # endif
-
687 #endif//GLM_MESSAGE
-
688 
-
689 #endif//glm_setup
+
655 # define GLM_CUDA_FUNC_DEF
+
656 # define GLM_CUDA_FUNC_DECL
+
657 #endif
+
658 
+
659 #if GLM_COMPILER & GLM_COMPILER_GCC
+
660 #define GLM_VAR_USED __attribute__ ((unused))
+
661 #else
+
662 #define GLM_VAR_USED
+
663 #endif
+
664 
+
665 #if(defined(GLM_FORCE_INLINE))
+
666 # if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
+
667 # define GLM_INLINE __forceinline
+
668 # elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
+
669 # define GLM_INLINE __attribute__((always_inline))
+
670 # else
+
671 # define GLM_INLINE inline
+
672 # endif//GLM_COMPILER
+
673 #else
+
674 # define GLM_INLINE inline
+
675 #endif//defined(GLM_FORCE_INLINE)
+
676 
+
677 #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+
678 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
+
679 
+
681 // Swizzle operators
+
682 
+
683 // User defines: GLM_SWIZZLE
+
684 
+
685 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
+
686 # define GLM_MESSAGE_SWIZZLE_DISPLAYED
+
687 # if(GLM_SUPPORT_SWIZZLE_OPERATOR())
+
688 # pragma message("GLM: Swizzling operators enabled")
+
689 # elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
+
690 # pragma message("GLM: Swizzling operators supported through swizzling functions")
+
691 # else
+
692 # pragma message("GLM: Swizzling operators disabled")
+
693 # endif
+
694 #endif//GLM_MESSAGE
+
695 
+
696 #endif//glm_setup
diff --git a/doc/api/a00085_source.html b/doc/api/a00085_source.html index 0bc867cb..4d3fe23e 100644 --- a/doc/api/a00085_source.html +++ b/doc/api/a00085_source.html @@ -135,99 +135,101 @@
91  fvec4SIMD const & v3);
92  explicit fmat4x4SIMD(
93  tmat4x4<float> const & m);
-
94 
-
95  // Conversions
-
96  //template <typename U>
-
97  //explicit tmat4x4(tmat4x4<U> const & m);
-
98 
-
99  //explicit tmat4x4(tmat2x2<T> const & x);
-
100  //explicit tmat4x4(tmat3x3<T> const & x);
-
101  //explicit tmat4x4(tmat2x3<T> const & x);
-
102  //explicit tmat4x4(tmat3x2<T> const & x);
-
103  //explicit tmat4x4(tmat2x4<T> const & x);
-
104  //explicit tmat4x4(tmat4x2<T> const & x);
-
105  //explicit tmat4x4(tmat3x4<T> const & x);
-
106  //explicit tmat4x4(tmat4x3<T> const & x);
-
107 
-
108  // Accesses
-
109  fvec4SIMD & operator[](size_type i);
-
110  fvec4SIMD const & operator[](size_type i) const;
-
111 
-
112  // Unary updatable operators
-
113  fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
-
114  fmat4x4SIMD & operator+= (float const & s);
-
115  fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
-
116  fmat4x4SIMD & operator-= (float const & s);
-
117  fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
-
118  fmat4x4SIMD & operator*= (float const & s);
-
119  fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
-
120  fmat4x4SIMD & operator/= (float const & s);
-
121  fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
-
122  fmat4x4SIMD & operator++ ();
-
123  fmat4x4SIMD & operator-- ();
-
124  };
-
125 
-
126  // Binary operators
-
127  fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
-
128  fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
-
129  fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-
130 
-
131  fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
-
132  fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
-
133  fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
-
134 
-
135  fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
-
136  fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
-
137 
-
138  fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
-
139  fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
-
140 
-
141  fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
94  explicit fmat4x4SIMD(
+
95  __m128 const in[4]);
+
96 
+
97  // Conversions
+
98  //template <typename U>
+
99  //explicit tmat4x4(tmat4x4<U> const & m);
+
100 
+
101  //explicit tmat4x4(tmat2x2<T> const & x);
+
102  //explicit tmat4x4(tmat3x3<T> const & x);
+
103  //explicit tmat4x4(tmat2x3<T> const & x);
+
104  //explicit tmat4x4(tmat3x2<T> const & x);
+
105  //explicit tmat4x4(tmat2x4<T> const & x);
+
106  //explicit tmat4x4(tmat4x2<T> const & x);
+
107  //explicit tmat4x4(tmat3x4<T> const & x);
+
108  //explicit tmat4x4(tmat4x3<T> const & x);
+
109 
+
110  // Accesses
+
111  fvec4SIMD & operator[](size_type i);
+
112  fvec4SIMD const & operator[](size_type i) const;
+
113 
+
114  // Unary updatable operators
+
115  fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
+
116  fmat4x4SIMD & operator+= (float const & s);
+
117  fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
+
118  fmat4x4SIMD & operator-= (float const & s);
+
119  fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
+
120  fmat4x4SIMD & operator*= (float const & s);
+
121  fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
+
122  fmat4x4SIMD & operator/= (float const & s);
+
123  fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
+
124  fmat4x4SIMD & operator++ ();
+
125  fmat4x4SIMD & operator-- ();
+
126  };
+
127 
+
128  // Binary operators
+
129  fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
+
130  fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
+
131  fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
132 
+
133  fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
+
134  fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
+
135  fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
136 
+
137  fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
+
138  fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
+
139 
+
140  fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
+
141  fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
142 
-
143  fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
-
144  fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
-
145 
-
146  fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
-
147  fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
-
148 
-
149  fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
143  fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
144 
+
145  fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
+
146  fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
+
147 
+
148  fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
+
149  fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
150 
-
151  // Unary constant operators
-
152  fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
-
153  fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
-
154  fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
-
155 }//namespace detail
-
156 
-
157  typedef detail::fmat4x4SIMD simdMat4;
+
151  fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
152 
+
153  // Unary constant operators
+
154  fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
+
155  fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
+
156  fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
+
157 }//namespace detail
158 
-
161 
-
164  detail::tmat4x4<float> mat4_cast(
-
165  detail::fmat4x4SIMD const & x);
-
166 
-
170  detail::fmat4x4SIMD matrixCompMult(
-
171  detail::fmat4x4SIMD const & x,
-
172  detail::fmat4x4SIMD const & y);
-
173 
-
178  detail::fmat4x4SIMD outerProduct(
-
179  detail::fvec4SIMD const & c,
-
180  detail::fvec4SIMD const & r);
-
181 
-
184  detail::fmat4x4SIMD transpose(
-
185  detail::fmat4x4SIMD const & x);
-
186 
-
189  float determinant(
-
190  detail::fmat4x4SIMD const & m);
-
191 
-
194  detail::fmat4x4SIMD inverse(
-
195  detail::fmat4x4SIMD const & m);
-
196 
-
198 }// namespace glm
-
199 
-
200 #include "simd_mat4.inl"
+
159  typedef detail::fmat4x4SIMD simdMat4;
+
160 
+
163 
+
166  detail::tmat4x4<float> mat4_cast(
+
167  detail::fmat4x4SIMD const & x);
+
168 
+
172  detail::fmat4x4SIMD matrixCompMult(
+
173  detail::fmat4x4SIMD const & x,
+
174  detail::fmat4x4SIMD const & y);
+
175 
+
180  detail::fmat4x4SIMD outerProduct(
+
181  detail::fvec4SIMD const & c,
+
182  detail::fvec4SIMD const & r);
+
183 
+
186  detail::fmat4x4SIMD transpose(
+
187  detail::fmat4x4SIMD const & x);
+
188 
+
191  float determinant(
+
192  detail::fmat4x4SIMD const & m);
+
193 
+
196  detail::fmat4x4SIMD inverse(
+
197  detail::fmat4x4SIMD const & m);
+
198 
+
200 }// namespace glm
201 
-
202 #endif//(GLM_ARCH != GLM_ARCH_PURE)
-
203 
-
204 #endif//GLM_GTX_simd_mat4
+
202 #include "simd_mat4.inl"
+
203 
+
204 #endif//(GLM_ARCH != GLM_ARCH_PURE)
+
205 
+
206 #endif//GLM_GTX_simd_mat4
diff --git a/doc/api/a00086_source.html b/doc/api/a00086_source.html index bb5d0c5b..7d73eb61 100644 --- a/doc/api/a00086_source.html +++ b/doc/api/a00086_source.html @@ -101,262 +101,284 @@
54 # pragma message("GLM: GLM_GTX_simd_vec4 extension included")
55 #endif
56 
-
57 namespace glm{
-
58 namespace detail
-
59 {
-
62  GLM_ALIGNED_STRUCT(16) fvec4SIMD
-
63  {
-
64  enum ctor{null};
-
65  typedef __m128 value_type;
-
66  typedef std::size_t size_type;
-
67  static size_type value_size();
-
68 
-
69  typedef fvec4SIMD type;
-
70  typedef tvec4<bool> bool_type;
-
71 
-
72  __m128 Data;
-
73 
-
75  // Implicit basic constructors
+
57 
+
58 // Warning silencer for nameless struct/union.
+
59 #if (GLM_COMPILER & GLM_COMPILER_VC)
+
60 # pragma warning(push)
+
61 # pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
+
62 #endif
+
63 
+
64 
+
65 namespace glm{
+
66 namespace detail
+
67 {
+
70  GLM_ALIGNED_STRUCT(16) fvec4SIMD
+
71  {
+
72  enum ctor{null};
+
73  typedef __m128 value_type;
+
74  typedef std::size_t size_type;
+
75  static size_type value_size();
76 
-
77  fvec4SIMD();
-
78  fvec4SIMD(__m128 const & Data);
-
79  fvec4SIMD(fvec4SIMD const & v);
-
80 
-
82  // Explicit basic constructors
-
83 
-
84  explicit fvec4SIMD(
-
85  ctor);
-
86  explicit fvec4SIMD(
-
87  float const & s);
-
88  explicit fvec4SIMD(
-
89  float const & x,
-
90  float const & y,
-
91  float const & z,
-
92  float const & w);
-
93  explicit fvec4SIMD(
-
94  tvec4<float> const & v);
-
95 
-
98 
-
99  fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
-
100  fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
-
101  fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
-
102  fvec4SIMD(vec3 const & v, float const & s);
-
103  fvec4SIMD(float const & s, vec3 const & v);
-
104  fvec4SIMD(vec2 const & v1, vec2 const & v2);
-
105  //fvec4SIMD(ivec4SIMD const & v);
-
106 
-
108  // Unary arithmetic operators
-
109 
-
110  fvec4SIMD& operator= (fvec4SIMD const & v);
-
111  fvec4SIMD& operator+=(fvec4SIMD const & v);
-
112  fvec4SIMD& operator-=(fvec4SIMD const & v);
-
113  fvec4SIMD& operator*=(fvec4SIMD const & v);
-
114  fvec4SIMD& operator/=(fvec4SIMD const & v);
-
115 
-
116  fvec4SIMD& operator+=(float const & s);
-
117  fvec4SIMD& operator-=(float const & s);
-
118  fvec4SIMD& operator*=(float const & s);
-
119  fvec4SIMD& operator/=(float const & s);
-
120 
-
121  fvec4SIMD& operator++();
-
122  fvec4SIMD& operator--();
-
123 
-
125  // Swizzle operators
-
126 
-
127  template <comp X, comp Y, comp Z, comp W>
-
128  fvec4SIMD& swizzle();
-
129  template <comp X, comp Y, comp Z, comp W>
-
130  fvec4SIMD swizzle() const;
-
131  template <comp X, comp Y, comp Z>
-
132  fvec4SIMD swizzle() const;
-
133  template <comp X, comp Y>
-
134  fvec4SIMD swizzle() const;
-
135  template <comp X>
-
136  fvec4SIMD swizzle() const;
-
137  };
-
138 }//namespace detail
+
77  typedef fvec4SIMD type;
+
78  typedef tvec4<bool> bool_type;
+
79 
+
80 #ifdef GLM_SIMD_ENABLE_XYZW_UNION
+
81  union
+
82  {
+
83  __m128 Data;
+
84  struct {float x, y, z, w;};
+
85  };
+
86 #else
+
87  __m128 Data;
+
88 #endif
+
89 
+
91  // Implicit basic constructors
+
92 
+
93  fvec4SIMD();
+
94  fvec4SIMD(__m128 const & Data);
+
95  fvec4SIMD(fvec4SIMD const & v);
+
96 
+
98  // Explicit basic constructors
+
99 
+
100  explicit fvec4SIMD(
+
101  ctor);
+
102  explicit fvec4SIMD(
+
103  float const & s);
+
104  explicit fvec4SIMD(
+
105  float const & x,
+
106  float const & y,
+
107  float const & z,
+
108  float const & w);
+
109  explicit fvec4SIMD(
+
110  tvec4<float> const & v);
+
111 
+
114 
+
115  fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
+
116  fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
+
117  fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
+
118  fvec4SIMD(vec3 const & v, float const & s);
+
119  fvec4SIMD(float const & s, vec3 const & v);
+
120  fvec4SIMD(vec2 const & v1, vec2 const & v2);
+
121  //fvec4SIMD(ivec4SIMD const & v);
+
122 
+
124  // Unary arithmetic operators
+
125 
+
126  fvec4SIMD& operator= (fvec4SIMD const & v);
+
127  fvec4SIMD& operator+=(fvec4SIMD const & v);
+
128  fvec4SIMD& operator-=(fvec4SIMD const & v);
+
129  fvec4SIMD& operator*=(fvec4SIMD const & v);
+
130  fvec4SIMD& operator/=(fvec4SIMD const & v);
+
131 
+
132  fvec4SIMD& operator+=(float const & s);
+
133  fvec4SIMD& operator-=(float const & s);
+
134  fvec4SIMD& operator*=(float const & s);
+
135  fvec4SIMD& operator/=(float const & s);
+
136 
+
137  fvec4SIMD& operator++();
+
138  fvec4SIMD& operator--();
139 
-
140  typedef glm::detail::fvec4SIMD simdVec4;
-
141 
-
144 
-
147  detail::tvec4<float> vec4_cast(
-
148  detail::fvec4SIMD const & x);
-
149 
-
152  detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
-
153 
-
156  detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
+
141  // Swizzle operators
+
142 
+
143  template <comp X, comp Y, comp Z, comp W>
+
144  fvec4SIMD& swizzle();
+
145  template <comp X, comp Y, comp Z, comp W>
+
146  fvec4SIMD swizzle() const;
+
147  template <comp X, comp Y, comp Z>
+
148  fvec4SIMD swizzle() const;
+
149  template <comp X, comp Y>
+
150  fvec4SIMD swizzle() const;
+
151  template <comp X>
+
152  fvec4SIMD swizzle() const;
+
153  };
+
154 }//namespace detail
+
155 
+
156  typedef glm::detail::fvec4SIMD simdVec4;
157 
-
160  detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
-
161 
-
165  detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
-
166 
-
173  detail::fvec4SIMD round(detail::fvec4SIMD const & x);
-
174 
-
179  //detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
-
180 
-
184  detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
-
185 
-
188  detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
-
189 
-
193  detail::fvec4SIMD mod(
-
194  detail::fvec4SIMD const & x,
-
195  detail::fvec4SIMD const & y);
+
160 
+
163  detail::tvec4<float> vec4_cast(
+
164  detail::fvec4SIMD const & x);
+
165 
+
168  detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
+
169 
+
172  detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
+
173 
+
176  detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
+
177 
+
181  detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
+
182 
+
189  detail::fvec4SIMD round(detail::fvec4SIMD const & x);
+
190 
+
195  //detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
196 
-
200  detail::fvec4SIMD mod(
-
201  detail::fvec4SIMD const & x,
-
202  float const & y);
-
203 
-
209  //detail::fvec4SIMD modf(
-
210  // detail::fvec4SIMD const & x,
-
211  // detail::fvec4SIMD & i);
+
200  detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
+
201 
+
204  detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
+
205 
+
209  detail::fvec4SIMD mod(
+
210  detail::fvec4SIMD const & x,
+
211  detail::fvec4SIMD const & y);
212 
-
215  detail::fvec4SIMD min(
-
216  detail::fvec4SIMD const & x,
-
217  detail::fvec4SIMD const & y);
-
218 
-
219  detail::fvec4SIMD min(
-
220  detail::fvec4SIMD const & x,
-
221  float const & y);
-
222 
-
225  detail::fvec4SIMD max(
-
226  detail::fvec4SIMD const & x,
-
227  detail::fvec4SIMD const & y);
+
216  detail::fvec4SIMD mod(
+
217  detail::fvec4SIMD const & x,
+
218  float const & y);
+
219 
+
225  //detail::fvec4SIMD modf(
+
226  // detail::fvec4SIMD const & x,
+
227  // detail::fvec4SIMD & i);
228 
-
229  detail::fvec4SIMD max(
-
230  detail::fvec4SIMD const & x,
-
231  float const & y);
-
232 
-
236  detail::fvec4SIMD clamp(
-
237  detail::fvec4SIMD const & x,
-
238  detail::fvec4SIMD const & minVal,
-
239  detail::fvec4SIMD const & maxVal);
-
240 
-
241  detail::fvec4SIMD clamp(
+
231  detail::fvec4SIMD min(
+
232  detail::fvec4SIMD const & x,
+
233  detail::fvec4SIMD const & y);
+
234 
+
235  detail::fvec4SIMD min(
+
236  detail::fvec4SIMD const & x,
+
237  float const & y);
+
238 
+
241  detail::fvec4SIMD max(
242  detail::fvec4SIMD const & x,
-
243  float const & minVal,
-
244  float const & maxVal);
-
245 
-
269  // \todo Test when 'a' is a boolean.
-
271  detail::fvec4SIMD mix(
-
272  detail::fvec4SIMD const & x,
-
273  detail::fvec4SIMD const & y,
-
274  detail::fvec4SIMD const & a);
-
275 
-
278  detail::fvec4SIMD step(
-
279  detail::fvec4SIMD const & edge,
-
280  detail::fvec4SIMD const & x);
-
281 
-
282  detail::fvec4SIMD step(
-
283  float const & edge,
-
284  detail::fvec4SIMD const & x);
-
285 
-
296  detail::fvec4SIMD smoothstep(
-
297  detail::fvec4SIMD const & edge0,
-
298  detail::fvec4SIMD const & edge1,
-
299  detail::fvec4SIMD const & x);
-
300 
-
301  detail::fvec4SIMD smoothstep(
-
302  float const & edge0,
-
303  float const & edge1,
-
304  detail::fvec4SIMD const & x);
-
305 
-
312  //bvec4 isnan(detail::fvec4SIMD const & x);
-
313 
-
320  //bvec4 isinf(detail::fvec4SIMD const & x);
+
243  detail::fvec4SIMD const & y);
+
244 
+
245  detail::fvec4SIMD max(
+
246  detail::fvec4SIMD const & x,
+
247  float const & y);
+
248 
+
252  detail::fvec4SIMD clamp(
+
253  detail::fvec4SIMD const & x,
+
254  detail::fvec4SIMD const & minVal,
+
255  detail::fvec4SIMD const & maxVal);
+
256 
+
257  detail::fvec4SIMD clamp(
+
258  detail::fvec4SIMD const & x,
+
259  float const & minVal,
+
260  float const & maxVal);
+
261 
+
285  // \todo Test when 'a' is a boolean.
+
287  detail::fvec4SIMD mix(
+
288  detail::fvec4SIMD const & x,
+
289  detail::fvec4SIMD const & y,
+
290  detail::fvec4SIMD const & a);
+
291 
+
294  detail::fvec4SIMD step(
+
295  detail::fvec4SIMD const & edge,
+
296  detail::fvec4SIMD const & x);
+
297 
+
298  detail::fvec4SIMD step(
+
299  float const & edge,
+
300  detail::fvec4SIMD const & x);
+
301 
+
312  detail::fvec4SIMD smoothstep(
+
313  detail::fvec4SIMD const & edge0,
+
314  detail::fvec4SIMD const & edge1,
+
315  detail::fvec4SIMD const & x);
+
316 
+
317  detail::fvec4SIMD smoothstep(
+
318  float const & edge0,
+
319  float const & edge1,
+
320  detail::fvec4SIMD const & x);
321 
-
326  //detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
-
327 
-
334  //detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
-
335 
-
338  detail::fvec4SIMD fma(
-
339  detail::fvec4SIMD const & a,
-
340  detail::fvec4SIMD const & b,
-
341  detail::fvec4SIMD const & c);
-
342 
-
352  //detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
-
353 
-
360  //detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
-
361 
-
364  float length(
-
365  detail::fvec4SIMD const & x);
-
366 
-
370  float fastLength(
-
371  detail::fvec4SIMD const & x);
-
372 
-
376  float niceLength(
-
377  detail::fvec4SIMD const & x);
-
378 
-
381  detail::fvec4SIMD length4(
-
382  detail::fvec4SIMD const & x);
-
383 
-
387  detail::fvec4SIMD fastLength4(
-
388  detail::fvec4SIMD const & x);
-
389 
-
393  detail::fvec4SIMD niceLength4(
-
394  detail::fvec4SIMD const & x);
-
395 
-
398  float distance(
-
399  detail::fvec4SIMD const & p0,
-
400  detail::fvec4SIMD const & p1);
-
401 
-
404  detail::fvec4SIMD distance4(
-
405  detail::fvec4SIMD const & p0,
-
406  detail::fvec4SIMD const & p1);
-
407 
-
410  float simdDot(
-
411  detail::fvec4SIMD const & x,
-
412  detail::fvec4SIMD const & y);
-
413 
-
416  detail::fvec4SIMD dot4(
-
417  detail::fvec4SIMD const & x,
-
418  detail::fvec4SIMD const & y);
-
419 
-
422  detail::fvec4SIMD cross(
-
423  detail::fvec4SIMD const & x,
-
424  detail::fvec4SIMD const & y);
-
425 
-
428  detail::fvec4SIMD normalize(
-
429  detail::fvec4SIMD const & x);
-
430 
-
434  detail::fvec4SIMD fastNormalize(
-
435  detail::fvec4SIMD const & x);
-
436 
-
439  detail::fvec4SIMD simdFaceforward(
-
440  detail::fvec4SIMD const & N,
-
441  detail::fvec4SIMD const & I,
-
442  detail::fvec4SIMD const & Nref);
-
443 
-
447  detail::fvec4SIMD reflect(
-
448  detail::fvec4SIMD const & I,
-
449  detail::fvec4SIMD const & N);
-
450 
-
455  detail::fvec4SIMD refract(
-
456  detail::fvec4SIMD const & I,
-
457  detail::fvec4SIMD const & N,
-
458  float const & eta);
+
328  //bvec4 isnan(detail::fvec4SIMD const & x);
+
329 
+
336  //bvec4 isinf(detail::fvec4SIMD const & x);
+
337 
+
342  //detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
+
343 
+
350  //detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
+
351 
+
354  detail::fvec4SIMD fma(
+
355  detail::fvec4SIMD const & a,
+
356  detail::fvec4SIMD const & b,
+
357  detail::fvec4SIMD const & c);
+
358 
+
368  //detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
+
369 
+
376  //detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
+
377 
+
380  float length(
+
381  detail::fvec4SIMD const & x);
+
382 
+
386  float fastLength(
+
387  detail::fvec4SIMD const & x);
+
388 
+
392  float niceLength(
+
393  detail::fvec4SIMD const & x);
+
394 
+
397  detail::fvec4SIMD length4(
+
398  detail::fvec4SIMD const & x);
+
399 
+
403  detail::fvec4SIMD fastLength4(
+
404  detail::fvec4SIMD const & x);
+
405 
+
409  detail::fvec4SIMD niceLength4(
+
410  detail::fvec4SIMD const & x);
+
411 
+
414  float distance(
+
415  detail::fvec4SIMD const & p0,
+
416  detail::fvec4SIMD const & p1);
+
417 
+
420  detail::fvec4SIMD distance4(
+
421  detail::fvec4SIMD const & p0,
+
422  detail::fvec4SIMD const & p1);
+
423 
+
426  float simdDot(
+
427  detail::fvec4SIMD const & x,
+
428  detail::fvec4SIMD const & y);
+
429 
+
432  detail::fvec4SIMD dot4(
+
433  detail::fvec4SIMD const & x,
+
434  detail::fvec4SIMD const & y);
+
435 
+
438  detail::fvec4SIMD cross(
+
439  detail::fvec4SIMD const & x,
+
440  detail::fvec4SIMD const & y);
+
441 
+
444  detail::fvec4SIMD normalize(
+
445  detail::fvec4SIMD const & x);
+
446 
+
450  detail::fvec4SIMD fastNormalize(
+
451  detail::fvec4SIMD const & x);
+
452 
+
455  detail::fvec4SIMD simdFaceforward(
+
456  detail::fvec4SIMD const & N,
+
457  detail::fvec4SIMD const & I,
+
458  detail::fvec4SIMD const & Nref);
459 
-
462  detail::fvec4SIMD sqrt(
-
463  detail::fvec4SIMD const & x);
-
464 
-
468  detail::fvec4SIMD niceSqrt(
-
469  detail::fvec4SIMD const & x);
-
470 
-
474  detail::fvec4SIMD fastSqrt(
-
475  detail::fvec4SIMD const & x);
-
476 
-
479  detail::fvec4SIMD inversesqrt(
-
480  detail::fvec4SIMD const & x);
-
481 
-
485  detail::fvec4SIMD fastInversesqrt(
-
486  detail::fvec4SIMD const & x);
-
487 
-
489 }//namespace glm
-
490 
-
491 #include "simd_vec4.inl"
+
463  detail::fvec4SIMD reflect(
+
464  detail::fvec4SIMD const & I,
+
465  detail::fvec4SIMD const & N);
+
466 
+
471  detail::fvec4SIMD refract(
+
472  detail::fvec4SIMD const & I,
+
473  detail::fvec4SIMD const & N,
+
474  float const & eta);
+
475 
+
478  detail::fvec4SIMD sqrt(
+
479  detail::fvec4SIMD const & x);
+
480 
+
484  detail::fvec4SIMD niceSqrt(
+
485  detail::fvec4SIMD const & x);
+
486 
+
490  detail::fvec4SIMD fastSqrt(
+
491  detail::fvec4SIMD const & x);
492 
-
493 #endif//(GLM_ARCH != GLM_ARCH_PURE)
-
494 
-
495 #endif//GLM_GTX_simd_vec4
+
495  detail::fvec4SIMD inversesqrt(
+
496  detail::fvec4SIMD const & x);
+
497 
+
501  detail::fvec4SIMD fastInversesqrt(
+
502  detail::fvec4SIMD const & x);
+
503 
+
505 }//namespace glm
+
506 
+
507 #include "simd_vec4.inl"
+
508 
+
509 
+
510 #if (GLM_COMPILER & GLM_COMPILER_VC)
+
511 # pragma warning(pop)
+
512 #endif
+
513 
+
514 
+
515 #endif//(GLM_ARCH != GLM_ARCH_PURE)
+
516 
+
517 #endif//GLM_GTX_simd_vec4
diff --git a/doc/api/a00096_source.html b/doc/api/a00096_source.html index 4c9adc00..42a4b92e 100644 --- a/doc/api/a00096_source.html +++ b/doc/api/a00096_source.html @@ -97,71 +97,72 @@
50  GLM_FUNC_DECL explicit half(U const & s);
51 
52  // Cast
-
53  template <typename U>
-
54  GLM_FUNC_DECL operator U() const;
-
55 
-
56  // Unary updatable operators
-
57  GLM_FUNC_DECL half& operator= (half const & s);
-
58  GLM_FUNC_DECL half& operator+=(half const & s);
-
59  GLM_FUNC_DECL half& operator-=(half const & s);
-
60  GLM_FUNC_DECL half& operator*=(half const & s);
-
61  GLM_FUNC_DECL half& operator/=(half const & s);
-
62  GLM_FUNC_DECL half& operator++();
-
63  GLM_FUNC_DECL half& operator--();
-
64 
-
65  GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
-
66 
-
67  GLM_FUNC_DECL hdata _data() const{return data;}
-
68 
-
69  private:
-
70  hdata data;
-
71  };
-
72 
-
73  half operator+ (half const & s1, half const & s2);
-
74 
-
75  half operator- (half const & s1, half const & s2);
-
76 
-
77  half operator* (half const & s1, half const & s2);
-
78 
-
79  half operator/ (half const & s1, half const & s2);
-
80 
-
81  // Unary constant operators
-
82  half operator- (half const & s);
-
83 
-
84  half operator-- (half const & s, int);
-
85 
-
86  half operator++ (half const & s, int);
-
87 
-
88  bool operator==(
-
89  detail::half const & x,
-
90  detail::half const & y);
-
91 
-
92  bool operator!=(
-
93  detail::half const & x,
-
94  detail::half const & y);
-
95 
-
96  bool operator<(
-
97  detail::half const & x,
-
98  detail::half const & y);
-
99 
-
100  bool operator<=(
-
101  detail::half const & x,
-
102  detail::half const & y);
-
103 
-
104  bool operator>(
-
105  detail::half const & x,
-
106  detail::half const & y);
-
107 
-
108  bool operator>=(
-
109  detail::half const & x,
-
110  detail::half const & y);
-
111 
-
112 }//namespace detail
-
113 }//namespace glm
-
114 
-
115 #include "type_half.inl"
-
116 
-
117 #endif//glm_core_type_half
+
53  //template <typename U>
+
54  //GLM_FUNC_DECL operator U() const;
+
55  GLM_FUNC_DECL operator float() const;
+
56 
+
57  // Unary updatable operators
+
58  GLM_FUNC_DECL half& operator= (half const & s);
+
59  GLM_FUNC_DECL half& operator+=(half const & s);
+
60  GLM_FUNC_DECL half& operator-=(half const & s);
+
61  GLM_FUNC_DECL half& operator*=(half const & s);
+
62  GLM_FUNC_DECL half& operator/=(half const & s);
+
63  GLM_FUNC_DECL half& operator++();
+
64  GLM_FUNC_DECL half& operator--();
+
65 
+
66  GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
+
67 
+
68  GLM_FUNC_DECL hdata _data() const{return data;}
+
69 
+
70  private:
+
71  hdata data;
+
72  };
+
73 
+
74  half operator+ (half const & s1, half const & s2);
+
75 
+
76  half operator- (half const & s1, half const & s2);
+
77 
+
78  half operator* (half const & s1, half const & s2);
+
79 
+
80  half operator/ (half const & s1, half const & s2);
+
81 
+
82  // Unary constant operators
+
83  half operator- (half const & s);
+
84 
+
85  half operator-- (half const & s, int);
+
86 
+
87  half operator++ (half const & s, int);
+
88 
+
89  bool operator==(
+
90  detail::half const & x,
+
91  detail::half const & y);
+
92 
+
93  bool operator!=(
+
94  detail::half const & x,
+
95  detail::half const & y);
+
96 
+
97  bool operator<(
+
98  detail::half const & x,
+
99  detail::half const & y);
+
100 
+
101  bool operator<=(
+
102  detail::half const & x,
+
103  detail::half const & y);
+
104 
+
105  bool operator>(
+
106  detail::half const & x,
+
107  detail::half const & y);
+
108 
+
109  bool operator>=(
+
110  detail::half const & x,
+
111  detail::half const & y);
+
112 
+
113 }//namespace detail
+
114 }//namespace glm
+
115 
+
116 #include "type_half.inl"
+
117 
+
118 #endif//glm_core_type_half
diff --git a/doc/api/a00122_source.html b/doc/api/a00122_source.html index d3c2276a..ac65d9a9 100644 --- a/doc/api/a00122_source.html +++ b/doc/api/a00122_source.html @@ -101,39 +101,39 @@
58  bool areCollinear(
59  genType const & v0,
60  genType const & v1,
-
61  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
61  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
62 
65  template <typename genType>
66  bool areOrthogonal(
67  genType const & v0,
68  genType const & v1,
-
69  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
69  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
70 
73  template <typename genType, template <typename> class vecType>
74  bool isNormalized(
75  vecType<genType> const & v,
-
76  genType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
+
76  genType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
77 
80  template <typename valType>
81  bool isNull(
82  detail::tvec2<valType> const & v,
-
83  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
83  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
84 
87  template <typename valType>
88  bool isNull(
89  detail::tvec3<valType> const & v,
-
90  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
90  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
91 
94  template <typename valType>
95  bool isNull(
96  detail::tvec4<valType> const & v,
-
97  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
97  valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
98 
101  template <typename genType>
102  bool areOrthonormal(
103  genType const & v0,
104  genType const & v1,
-
105  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
105  typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
106 
108 }// namespace glm
109 
diff --git a/doc/api/a00129.html b/doc/api/a00129.html index e6bd34bc..1d0b3d64 100644 --- a/doc/api/a00129.html +++ b/doc/api/a00129.html @@ -669,14 +669,14 @@ If genTypeU is a boolean scalar or vector: Selects which vector each returned co
...
float a;
bool b;
-
glm::dvec3 e;
+
glm::dvec3 e;
glm::dvec3 f;
glm::vec4 g;
glm::vec4 h;
...
glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
-
glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
+
glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.

Referenced by glm::lerp(), and glm::slerp().

diff --git a/doc/api/a00145.html b/doc/api/a00145.html index 8c8d1eea..23a59ab6 100644 --- a/doc/api/a00145.html +++ b/doc/api/a00145.html @@ -41,92 +41,92 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Functions

template<typename T >
GLM_CONSTEXPR T e ()
 
template<typename T >
GLM_CONSTEXPR T epsilon ()
 
template<typename T >
GLM_CONSTEXPR T euler ()
 
template<typename T >
GLM_CONSTEXPR T golden_ratio ()
 
template<typename T >
GLM_CONSTEXPR T half_pi ()
 
template<typename T >
GLM_CONSTEXPR T ln_ln_two ()
 
template<typename T >
GLM_CONSTEXPR T ln_ten ()
 
template<typename T >
GLM_CONSTEXPR T ln_two ()
 
template<typename T >
GLM_CONSTEXPR T one ()
 
template<typename T >
GLM_CONSTEXPR T one_over_pi ()
 
template<typename T >
GLM_CONSTEXPR T one_over_root_two ()
 
template<typename T >
GLM_CONSTEXPR T pi ()
 
template<typename T >
GLM_CONSTEXPR T quarter_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_five ()
 
template<typename T >
GLM_CONSTEXPR T root_half_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_ln_four ()
 
template<typename T >
GLM_CONSTEXPR T root_pi ()
 
template<typename T >
GLM_CONSTEXPR T root_three ()
 
template<typename T >
GLM_CONSTEXPR T root_two ()
 
template<typename T >
GLM_CONSTEXPR T root_two_pi ()
 
template<typename T >
GLM_CONSTEXPR T third ()
 
template<typename T >
GLM_CONSTEXPR T two_over_pi ()
 
template<typename T >
GLM_CONSTEXPR T two_over_root_pi ()
 
template<typename T >
GLM_CONSTEXPR T two_thirds ()
 
template<typename T >
GLM_CONSTEXPR T zero ()
 
template<typename genType >
genType e ()
 
template<typename genType >
genType epsilon ()
 
template<typename genType >
genType euler ()
 
template<typename genType >
genType golden_ratio ()
 
template<typename genType >
genType half_pi ()
 
template<typename genType >
genType ln_ln_two ()
 
template<typename genType >
genType ln_ten ()
 
template<typename genType >
genType ln_two ()
 
template<typename genType >
genType one ()
 
template<typename genType >
genType one_over_pi ()
 
template<typename genType >
genType one_over_root_two ()
 
template<typename genType >
genType pi ()
 
template<typename genType >
genType quarter_pi ()
 
template<typename genType >
genType root_five ()
 
template<typename genType >
genType root_half_pi ()
 
template<typename genType >
genType root_ln_four ()
 
template<typename genType >
genType root_pi ()
 
template<typename genType >
genType root_three ()
 
template<typename genType >
genType root_two ()
 
template<typename genType >
genType root_two_pi ()
 
template<typename genType >
genType third ()
 
template<typename genType >
genType two_over_pi ()
 
template<typename genType >
genType two_over_root_pi ()
 
template<typename genType >
genType two_thirds ()
 
template<typename genType >
genType zero ()
 

Detailed Description

Allow to perform bit operations on integer values.

<glm/gtc/constants.hpp> need to be included to use these features.

Function Documentation

- +
- + @@ -139,12 +139,12 @@ Functions - +
GLM_CONSTEXPR T glm::e genType glm::e ( )
- + @@ -158,12 +158,12 @@ Functions - +
GLM_CONSTEXPR T glm::epsilon genType glm::epsilon ( )
- + @@ -176,12 +176,12 @@ Functions - +
GLM_CONSTEXPR T glm::euler genType glm::euler ( )
- + @@ -194,12 +194,12 @@ Functions - +
GLM_CONSTEXPR T glm::golden_ratio genType glm::golden_ratio ( )
- + @@ -212,12 +212,12 @@ Functions - +
GLM_CONSTEXPR T glm::half_pi genType glm::half_pi ( )
- + @@ -230,12 +230,12 @@ Functions - +
GLM_CONSTEXPR T glm::ln_ln_two genType glm::ln_ln_two ( )
- + @@ -248,12 +248,12 @@ Functions - +
GLM_CONSTEXPR T glm::ln_ten genType glm::ln_ten ( )
- + @@ -266,12 +266,12 @@ Functions - +
GLM_CONSTEXPR T glm::ln_two genType glm::ln_two ( )
- + @@ -284,12 +284,12 @@ Functions - +
GLM_CONSTEXPR T glm::one genType glm::one ( )
- + @@ -302,12 +302,12 @@ Functions - +
GLM_CONSTEXPR T glm::one_over_pi genType glm::one_over_pi ( )
- + @@ -320,12 +320,12 @@ Functions - +
GLM_CONSTEXPR T glm::one_over_root_two genType glm::one_over_root_two ( )
- + @@ -338,12 +338,12 @@ Functions - +
GLM_CONSTEXPR T glm::pi genType glm::pi ( )
- + @@ -356,12 +356,12 @@ Functions - +
GLM_CONSTEXPR T glm::quarter_pi genType glm::quarter_pi ( )
- + @@ -374,12 +374,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_five genType glm::root_five ( )
- + @@ -392,12 +392,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_half_pi genType glm::root_half_pi ( )
- + @@ -410,12 +410,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_ln_four genType glm::root_ln_four ( )
- + @@ -428,12 +428,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_pi genType glm::root_pi ( )
- + @@ -446,12 +446,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_three genType glm::root_three ( )
- + @@ -464,12 +464,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_two genType glm::root_two ( )
- + @@ -482,12 +482,12 @@ Functions - +
GLM_CONSTEXPR T glm::root_two_pi genType glm::root_two_pi ( )
- + @@ -500,12 +500,12 @@ Functions - +
GLM_CONSTEXPR T glm::third genType glm::third ( )
- + @@ -518,12 +518,12 @@ Functions - +
GLM_CONSTEXPR T glm::two_over_pi genType glm::two_over_pi ( )
- + @@ -536,12 +536,12 @@ Functions - +
GLM_CONSTEXPR T glm::two_over_root_pi genType glm::two_over_root_pi ( )
- + @@ -554,12 +554,12 @@ Functions - +
GLM_CONSTEXPR T glm::two_thirds genType glm::two_thirds ( )
- + diff --git a/doc/api/a00151.html b/doc/api/a00151.html index ea0be2c3..cc2d4a17 100644 --- a/doc/api/a00151.html +++ b/doc/api/a00151.html @@ -650,7 +650,7 @@ Functions
Template Parameters
GLM_CONSTEXPR T glm::zero genType glm::zero ( )
- +
TValue type used to build the matrix. Currently supported: half (not recommanded), float or double.
TValue type used to build the matrix. Supported: half, float or double.
diff --git a/doc/api/a00153.html b/doc/api/a00153.html index 3032fcd5..c79a7bd7 100644 --- a/doc/api/a00153.html +++ b/doc/api/a00153.html @@ -89,6 +89,9 @@ Functions template<typename T > T length (detail::tquat< T > const &q)   +template<typename T > +detail::tquat< T > lerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) +  template<typename T > detail::tmat3x3< T > mat3_cast (detail::tquat< T > const &x)   @@ -101,15 +104,27 @@ Functions template<typename T > detail::tquat< T > normalize (detail::tquat< T > const &q)   +template<typename valType > +valType pitch (detail::tquat< valType > const &x) +  template<typename T > detail::tquat< T > quat_cast (detail::tmat3x3< T > const &x)   template<typename T > detail::tquat< T > quat_cast (detail::tmat4x4< T > const &x)   +template<typename valType > +valType roll (detail::tquat< valType > const &x) +  template<typename T > detail::tquat< T > rotate (detail::tquat< T > const &q, typename detail::tquat< T >::value_type const &angle, detail::tvec3< T > const &axis)   +template<typename T > +detail::tquat< T > slerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) +  +template<typename valType > +valType yaw (detail::tquat< valType > const &x) + 

Detailed Description

Defines a templated quaternion type and several quaternion operations.

@@ -128,7 +143,7 @@ Functions

Quaternion of double-precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 301 of file gtc/quaternion.hpp.

+

Definition at line 359 of file gtc/quaternion.hpp.

@@ -145,7 +160,7 @@ Functions

Quaternion of single-precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 296 of file gtc/quaternion.hpp.

+

Definition at line 354 of file gtc/quaternion.hpp.

@@ -162,7 +177,7 @@ Functions

Quaternion of high precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 316 of file gtc/quaternion.hpp.

+

Definition at line 374 of file gtc/quaternion.hpp.

@@ -179,7 +194,7 @@ Functions

Quaternion of half-precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 291 of file gtc/quaternion.hpp.

+

Definition at line 349 of file gtc/quaternion.hpp.

@@ -196,7 +211,7 @@ Functions

Quaternion of low precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 306 of file gtc/quaternion.hpp.

+

Definition at line 364 of file gtc/quaternion.hpp.

@@ -213,7 +228,7 @@ Functions

Quaternion of medium precision floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 311 of file gtc/quaternion.hpp.

+

Definition at line 369 of file gtc/quaternion.hpp.

@@ -230,7 +245,7 @@ Functions

Quaternion of floating-point numbers.

See Also
GLM_GTC_quaternion
-

Definition at line 286 of file gtc/quaternion.hpp.

+

Definition at line 344 of file gtc/quaternion.hpp.

@@ -462,6 +477,56 @@ Functions

Returns the length of the quaternion.

See Also
GLM_GTC_quaternion
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
detail::tquat<T> glm::lerp (detail::tquat< T > const & x,
detail::tquat< T > const & y,
T const & a 
)
+
+ +

Linear interpolation of two quaternions.

+

The interpolation is oriented.

+
Parameters
+ + + + +
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined in the range [0, 1].
+
+
+
Template Parameters
+ + +
TValue type used to build the quaternion. Supported: half, float or double.
+
+
+
See Also
GLM_GTC_quaternion
+
@@ -481,7 +546,7 @@ Functions

Converts a quaternion to a 3 * 3 matrix.

See Also
GLM_GTC_quaternion
-

Referenced by glm::toMat3().

+

Referenced by glm::toMat3().

@@ -502,7 +567,7 @@ Functions

Converts a quaternion to a 4 * 4 matrix.

See Also
GLM_GTC_quaternion
-

Referenced by glm::toMat4().

+

Referenced by glm::toMat4().

@@ -536,8 +601,25 @@ Functions
-

Returns a SLERP interpolated quaternion of x and y according a.

-
See Also
GLM_GTC_quaternion
+

Spherical linear interpolation of two quaternions.

+

The interpolation is oriented and the rotation is performed at constant speed. For short path spherical linear interpolation, use the slerp function.

+
Parameters
+ + + + +
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined beyond the range [0, 1].
+
+
+
Template Parameters
+ + +
TValue type used to build the quaternion. Supported: half, float or double.
+
+
+
See Also
GLM_GTC_quaternion
+
+- slerp(detail::tquat<T> const & x, detail::tquat<T> const & y, T const & a)
@@ -558,6 +640,25 @@ Functions

Returns the normalized quaternion.

See Also
GLM_GTC_quaternion
+ + + +
+
+ + + + + + + + +
valType glm::pitch (detail::tquat< valType > const & x)
+
+ +

Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

+
See Also
GLM_GTX_quaternion
+
@@ -577,7 +678,7 @@ Functions

Converts a 3 * 3 matrix to a quaternion.

See Also
GLM_GTC_quaternion
-

Referenced by glm::toQuat().

+

Referenced by glm::toQuat().

@@ -598,6 +699,25 @@ Functions

Converts a 4 * 4 matrix to a quaternion.

See Also
GLM_GTC_quaternion
+ + + +
+
+ + + + + + + + +
valType glm::roll (detail::tquat< valType > const & x)
+
+ +

Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

+
See Also
GLM_GTX_quaternion
+
@@ -641,6 +761,80 @@ Functions
See Also
GLM_GTC_quaternion
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
GLM_FUNC_QUALIFIER T slerp (detail::tquat< T > const & x,
detail::tquat< T > const & y,
T const & a 
)
+
+ +

Spherical linear interpolation of two quaternions.

+

Returns the slurp interpolation between two quaternions.

+

The interpolation always take the short path and the rotation is performed at constant speed.

+
Parameters
+ + + + +
xA quaternion
yA quaternion
aInterpolation factor. The interpolation is defined beyond the range [0, 1].
+
+
+
Template Parameters
+ + +
TValue type used to build the quaternion. Supported: half, float or double.
+
+
+
See Also
GLM_GTC_quaternion
+ +

Definition at line 73 of file compatibility.hpp.

+ +

References glm::mix().

+ +
+
+ +
+
+ + + + + + + + +
valType glm::yaw (detail::tquat< valType > const & x)
+
+ +

Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

+
See Also
GLM_GTX_quaternion
+
diff --git a/doc/api/a00166.html b/doc/api/a00166.html index 79e59a7d..0ac2400a 100644 --- a/doc/api/a00166.html +++ b/doc/api/a00166.html @@ -355,10 +355,6 @@ template<typename T > GLM_FUNC_QUALIFIER
detail::tvec4< T > saturate (const detail::tvec4< T > &x)   - -template<typename T > -GLM_FUNC_QUALIFIER T slerp (detail::tquat< T > const &x, detail::tquat< T > const &y, T const &a) - 

Detailed Description

Provide functions to increase the compatibility with Cg and HLSL languages.

diff --git a/doc/api/a00188.html b/doc/api/a00188.html index f93ef5b5..e8b532f0 100644 --- a/doc/api/a00188.html +++ b/doc/api/a00188.html @@ -76,7 +76,7 @@ Functions  

Detailed Description

-

Various way to compute vector norms.

+

Various ways to compute vector norms.

<glm/gtx/norm.hpp> need to be included to use these functionalities.

Function Documentation

diff --git a/doc/api/a00198.html b/doc/api/a00198.html index 92e8eed4..61867e51 100644 --- a/doc/api/a00198.html +++ b/doc/api/a00198.html @@ -47,9 +47,6 @@ Functions template<typename valType > detail::tvec3< valType > cross (detail::tvec3< valType > const &v, detail::tquat< valType > const &q)   -template<typename valType > -detail::tvec3< valType > eulerAngles (detail::tquat< valType > const &x) -  template<typename valType > detail::tquat< valType > exp (detail::tquat< valType > const &q, valType const &exponent)   @@ -65,15 +62,9 @@ Functions template<typename valType > detail::tquat< valType > log (detail::tquat< valType > const &q)   -template<typename valType > -valType pitch (detail::tquat< valType > const &x) -  template<typename valType > detail::tquat< valType > pow (detail::tquat< valType > const &x, valType const &y)   -template<typename valType > -valType roll (detail::tquat< valType > const &x) -  template<typename valType > detail::tvec3< valType > rotate (detail::tquat< valType > const &q, detail::tvec3< valType > const &v)   @@ -98,9 +89,6 @@ Functions template<typename valType > detail::tquat< valType > toQuat (detail::tmat4x4< valType > const &x)   -template<typename valType > -valType yaw (detail::tquat< valType > const &x) - 

Detailed Description

Extented quaternion types and functions.

@@ -162,25 +150,6 @@ Functions

Compute a cross product between a vector and a quaternion.

See Also
GLM_GTX_quaternion
- - - -
-
- - - - - - - - -
detail::tvec3<valType> glm::eulerAngles (detail::tquat< valType > const & x)
-
- -

Returns euler angles, yitch as x, yaw as y, roll as z.

-
See Also
GLM_GTX_quaternion
-
@@ -318,25 +287,6 @@ Functions

Returns a log of a quaternion.

See Also
GLM_GTX_quaternion
- - - -
-
- - - - - - - - -
valType glm::pitch (detail::tquat< valType > const & x)
-
- -

Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

-
See Also
GLM_GTX_quaternion
-
@@ -366,25 +316,6 @@ Functions

Returns x raised to the y power.

See Also
GLM_GTX_quaternion
- - - -
-
- - - - - - - - -
valType glm::roll (detail::tquat< valType > const & x)
-
- -

Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

-
See Also
GLM_GTX_quaternion
-
@@ -547,7 +478,7 @@ Functions

Converts a quaternion to a 3 * 3 matrix.

See Also
GLM_GTX_quaternion
-

Definition at line 177 of file gtx/quaternion.hpp.

+

Definition at line 149 of file gtx/quaternion.hpp.

References glm::mat3_cast().

@@ -570,7 +501,7 @@ Functions

Converts a quaternion to a 4 * 4 matrix.

See Also
GLM_GTX_quaternion
-

Definition at line 184 of file gtx/quaternion.hpp.

+

Definition at line 156 of file gtx/quaternion.hpp.

References glm::mat4_cast().

@@ -593,7 +524,7 @@ Functions

Converts a 3 * 3 matrix to a quaternion.

See Also
GLM_GTX_quaternion
-

Definition at line 191 of file gtx/quaternion.hpp.

+

Definition at line 163 of file gtx/quaternion.hpp.

References glm::quat_cast().

@@ -616,29 +547,10 @@ Functions

Converts a 4 * 4 matrix to a quaternion.

See Also
GLM_GTX_quaternion
-

Definition at line 198 of file gtx/quaternion.hpp.

+

Definition at line 170 of file gtx/quaternion.hpp.

References glm::quat_cast().

- - - -
-
- - - - - - - - -
valType glm::yaw (detail::tquat< valType > const & x)
-
- -

Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

-
See Also
GLM_GTX_quaternion
-
diff --git a/doc/api/a00215.html b/doc/api/a00215.html index 2d7bdd8f..1b36457e 100644 --- a/doc/api/a00215.html +++ b/doc/api/a00215.html @@ -39,7 +39,7 @@
Member glm::bitCount (genIUType< T > const &Value)
Clarify the declaration to specify that scalars are suported.
-
Member glm::epsilon ()
+
Member glm::epsilon ()
Implement epsilon for half-precision floating point type.
Member glm::findLSB (genIUType< T > const &Value)
Clarify the declaration to specify that scalars are suported.
diff --git a/doc/api/modules.html b/doc/api/modules.html index 9620f3d9..f7246f8d 100644 --- a/doc/api/modules.html +++ b/doc/api/modules.html @@ -83,7 +83,7 @@ |oGLM_GTX_matrix_queryQuery to evaluate matrix properties |oGLM_GTX_mixed_producteMixed product of 3 vectors |oGLM_GTX_multipleFind the closest number of a number multiple of other number -|oGLM_GTX_normVarious way to compute vector norms +|oGLM_GTX_normVarious ways to compute vector norms |oGLM_GTX_normalCompute the normal of a triangle |oGLM_GTX_normalize_dotDot product of vectors that need to be normalize with a single square root |oGLM_GTX_number_precisionDefined size types