anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269

Browse Source
master
Christophe Riccio ago%!(EXTRA string=11 years)
parent 9c62eee507
commit 3adf263341
17 changed files with 595 additions and 468 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. BIN
      doc/glm.docx
  2. 10
      glm/detail/type_mat2x2.hpp
  3. 11
      glm/detail/type_mat2x3.hpp
  4. 10
      glm/detail/type_mat2x4.hpp
  5. 12
      glm/detail/type_mat3x2.hpp
  6. 12
      glm/detail/type_mat3x3.hpp
  7. 11
      glm/detail/type_mat3x4.hpp
  8. 11
      glm/detail/type_mat4x2.hpp
  9. 11
      glm/detail/type_mat4x3.hpp
  10. 11
      glm/detail/type_mat4x4.hpp
  11. 9
      glm/gtc/quaternion.hpp
  12. 11
      glm/gtc/quaternion.inl
  13. 8
      glm/gtx/dual_quaternion.hpp
  14. 11
      glm/gtx/dual_quaternion.inl
  15. 1
      readme.txt
  16. 895
      test/core/core_func_common.cpp
  17. 11
      test/core/core_type_mat4x4.cpp

BIN
doc/glm.docx
View File

Binary file not shown.

10
glm/detail/type_mat2x2.hpp
Unescape View File

@ -92,8 +92,14 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x2(tmat2x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x); GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);

11
glm/detail/type_mat2x3.hpp
Unescape View File

@ -75,6 +75,7 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Conversions // Conversions
template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
GLM_FUNC_DECL tmat2x3( GLM_FUNC_DECL tmat2x3(
X1 const & x1, Y1 const & y1, Z1 const & z1, X1 const & x1, Y1 const & y1, Z1 const & z1,
@ -87,8 +88,14 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversion // Matrix conversion
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x3(tmat2x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);

10
glm/detail/type_mat2x4.hpp
Unescape View File

@ -89,8 +89,14 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x4(tmat2x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);

12
glm/detail/type_mat3x2.hpp
Unescape View File

@ -77,6 +77,7 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Conversions // Conversions
template< template<
typename X1, typename Y1, typename X1, typename Y1,
typename X2, typename Y2, typename X2, typename Y2,
@ -92,9 +93,16 @@ namespace glm
tvec2<V2, P> const & v2, tvec2<V2, P> const & v2,
tvec2<V3, P> const & v3); tvec2<V3, P> const & v3);
//////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x2(tmat3x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);

12
glm/detail/type_mat3x3.hpp
Unescape View File

@ -81,6 +81,7 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Conversions // Conversions
template< template<
typename X1, typename Y1, typename Z1, typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2, typename X2, typename Y2, typename Z2,
@ -96,9 +97,16 @@ namespace glm
tvec3<V2, P> const & v2, tvec3<V2, P> const & v2,
tvec3<V3, P> const & v3); tvec3<V3, P> const & v3);
//////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x3(tmat3x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x); GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);

11
glm/detail/type_mat3x4.hpp
Unescape View File

@ -92,9 +92,16 @@ namespace glm
tvec4<V2, P> const & v2, tvec4<V2, P> const & v2,
tvec4<V3, P> const & v3); tvec4<V3, P> const & v3);
//////////////////////////////////////
// Matrix conversion // Matrix conversion
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x4(tmat3x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);

11
glm/detail/type_mat4x2.hpp
Unescape View File

@ -98,9 +98,16 @@ namespace glm
tvec2<V3, P> const & v3, tvec2<V3, P> const & v3,
tvec2<V4, P> const & v4); tvec2<V4, P> const & v4);
//////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x2(tmat4x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);

11
glm/detail/type_mat4x3.hpp
Unescape View File

@ -97,9 +97,16 @@ namespace glm
tvec3<V3, P> const & v3, tvec3<V3, P> const & v3,
tvec3<V4, P> const & v4); tvec3<V4, P> const & v4);
//////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x3(tmat4x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);

11
glm/detail/type_mat4x4.hpp
Unescape View File

@ -103,9 +103,16 @@ namespace glm
tvec4<V3, P> const & v3, tvec4<V3, P> const & v3,
tvec4<V4, P> const & v4); tvec4<V4, P> const & v4);
//////////////////////////////////////
// Matrix conversions // Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m); # ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x4(tmat4x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);

9
glm/gtc/quaternion.hpp
Unescape View File

@ -95,6 +95,14 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Convertions // Convertions
# ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tquat(tquat<U, Q> const & q);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tquat(tquat<U, Q> const & q);
# endif
/// Create a quaternion from two normalized axis /// Create a quaternion from two normalized axis
/// ///
/// @param u A first normalized axis /// @param u A first normalized axis
@ -102,6 +110,7 @@ namespace glm
/// @see gtc_quaternion /// @see gtc_quaternion
/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors /// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & u, tvec3<T, P> const & v); GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & u, tvec3<T, P> const & v);
/// Build a quaternion from euler angles (pitch, yaw, roll), in radians. /// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & eulerAngles); GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & eulerAngles);
GLM_FUNC_DECL explicit tquat(tmat3x3<T, P> const & m); GLM_FUNC_DECL explicit tquat(tmat3x3<T, P> const & m);

11
glm/gtc/quaternion.inl
Unescape View File

@ -106,12 +106,21 @@ namespace detail
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(T const & w, T const & x, T const & y, T const & z) GLM_FUNC_QUALIFIER tquat<T, P>::tquat(T const & w, T const & x, T const & y, T const & z)
: x(x), y(y), z(z), w(w) : x(x), y(y), z(z), w(w)
{} {}
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// Conversions // Conversions
template <typename T, precision P>
template <typename U, precision Q>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tquat<U, Q> const & q)
: x(static_cast<T>(q.x))
, y(static_cast<T>(q.y))
, z(static_cast<T>(q.z))
, w(static_cast<T>(q.w))
{}
//template <typename valType> //template <typename valType>
//GLM_FUNC_QUALIFIER tquat<valType>::tquat //GLM_FUNC_QUALIFIER tquat<valType>::tquat
//( //(

8
glm/gtx/dual_quaternion.hpp
Unescape View File

@ -89,6 +89,14 @@ namespace glm
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// tdualquat conversions // tdualquat conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tdualquat(tdualquat<U, Q> const & q);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tdualquat(tdualquat<U, Q> const & q);
# endif
GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat); GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat); GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);

11
glm/gtx/dual_quaternion.inl
Unescape View File

@ -56,7 +56,8 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <precision Q> template <precision Q>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d) GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
: real(d.real), dual(d.dual) : real(d.real)
, dual(d.dual)
{} {}
////////////////////////////////////// //////////////////////////////////////
@ -87,6 +88,14 @@ namespace glm
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// tdualquat conversions // tdualquat conversions
template <typename T, precision P>
template <typename U, precision Q>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
: real(q.real)
, dual(q.dual)
{}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m) GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
{ {

1
readme.txt
Unescape View File

@ -57,6 +57,7 @@ Features:
- Added GTC_bitfield extension, promoted GTX_bit - Added GTC_bitfield extension, promoted GTX_bit
- Added GTC_integer extension, promoted GTX_bit - Added GTC_integer extension, promoted GTX_bit
- Added GTC_round extension, promoted GTX_bit - Added GTC_round extension, promoted GTX_bit
- Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269
Improvements: Improvements:
- Rely on C++11 to implement isinf and isnan - Rely on C++11 to implement isinf and isnan

895
test/core/core_func_common.cpp
View File

File diff suppressed because it is too large Load Diff

11
test/core/core_type_mat4x4.cpp
Unescape View File

@ -13,16 +13,9 @@
#include <cstdio> #include <cstdio>
#include <vector> #include <vector>
void print(glm::dmat4 const & Mat0)
{
printf("mat4(\n");
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2], Mat0[1][3]);
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[2][0], Mat0[2][1], Mat0[2][2], Mat0[2][3]);
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", Mat0[3][0], Mat0[3][1], Mat0[3][2], Mat0[3][3]);
}
void print(glm::mat4 const & Mat0) template <typename genType>
void print(genType const & Mat0)
{ {
printf("mat4(\n"); printf("mat4(\n");
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]); printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);

Write Preview
Loading…
Cancel
Save