Removed last references to GLM_FORCE_RADIANS

master
Christophe Riccio ago%!(EXTRA string=11 years)
parent fa6bec2f3d
commit 2b747cbbad
  1. 1
      glm/detail/dummy.cpp
  2. 12
      glm/gtc/matrix_transform.hpp
  3. 73
      glm/gtc/matrix_transform.inl
  4. 10
      glm/gtc/quaternion.hpp
  5. 34
      glm/gtc/quaternion.inl
  6. 10
      glm/gtx/matrix_transform_2d.inl
  7. 14
      glm/gtx/polar_coordinates.inl
  8. 22
      glm/gtx/rotate_normalized_axis.inl
  9. 4
      glm/gtx/simd_quat.hpp
  10. 1
      readme.txt
  11. 1
      test/core/core_func_common.cpp
  12. 1
      test/core/core_func_exponential.cpp
  13. 1
      test/core/core_func_geometric.cpp
  14. 1
      test/core/core_func_integer.cpp
  15. 1
      test/core/core_func_matrix.cpp
  16. 2
      test/core/core_func_noise.cpp
  17. 1
      test/core/core_func_packing.cpp
  18. 1
      test/core/core_func_swizzle.cpp
  19. 1
      test/core/core_func_trigonometric.cpp
  20. 1
      test/core/core_func_vector_relational.cpp
  21. 1
      test/core/core_type_cast.cpp
  22. 1
      test/core/core_type_float.cpp
  23. 1
      test/core/core_type_int.cpp
  24. 1
      test/core/core_type_length.cpp
  25. 1
      test/core/core_type_mat2x2.cpp
  26. 1
      test/core/core_type_mat2x3.cpp
  27. 1
      test/core/core_type_mat2x4.cpp
  28. 1
      test/core/core_type_mat3x2.cpp
  29. 1
      test/core/core_type_mat3x3.cpp
  30. 1
      test/core/core_type_mat3x4.cpp
  31. 1
      test/core/core_type_mat4x2.cpp
  32. 1
      test/core/core_type_mat4x3.cpp
  33. 1
      test/core/core_type_mat4x4.cpp
  34. 1
      test/core/core_type_vec1.cpp
  35. 1
      test/core/core_type_vec2.cpp
  36. 1
      test/core/core_type_vec3.cpp
  37. 1
      test/core/core_type_vec4.cpp
  38. 1
      test/gtc/gtc_constants.cpp
  39. 1
      test/gtc/gtc_epsilon.cpp
  40. 1
      test/gtc/gtc_matrix_access.cpp
  41. 1
      test/gtc/gtc_matrix_integer.cpp
  42. 1
      test/gtc/gtc_matrix_inverse.cpp
  43. 1
      test/gtc/gtc_matrix_transform.cpp
  44. 1
      test/gtc/gtc_noise.cpp
  45. 1
      test/gtc/gtc_packing.cpp
  46. 1
      test/gtc/gtc_quaternion.cpp
  47. 1
      test/gtc/gtc_random.cpp
  48. 1
      test/gtc/gtc_reciprocal.cpp
  49. 1
      test/gtc/gtc_type_precision.cpp
  50. 1
      test/gtc/gtc_type_ptr.cpp
  51. 1
      test/gtc/gtc_ulp.cpp
  52. 1
      test/gtx/gtx_associated_min_max.cpp
  53. 1
      test/gtx/gtx_bit.cpp
  54. 1
      test/gtx/gtx_closest_point.cpp
  55. 1
      test/gtx/gtx_color_space.cpp
  56. 1
      test/gtx/gtx_color_space_YCoCg.cpp
  57. 1
      test/gtx/gtx_compatibility.cpp
  58. 1
      test/gtx/gtx_component_wise.cpp
  59. 1
      test/gtx/gtx_dual_quaternion.cpp
  60. 1
      test/gtx/gtx_euler_angle.cpp
  61. 1
      test/gtx/gtx_extend.cpp
  62. 1
      test/gtx/gtx_extented_min_max.cpp
  63. 1
      test/gtx/gtx_fast_exponential.cpp
  64. 1
      test/gtx/gtx_fast_square_root.cpp
  65. 1
      test/gtx/gtx_fast_trigonometry.cpp
  66. 1
      test/gtx/gtx_gradient_paint.cpp
  67. 1
      test/gtx/gtx_handed_coordinate_space.cpp
  68. 1
      test/gtx/gtx_inertia.cpp
  69. 1
      test/gtx/gtx_integer.cpp
  70. 1
      test/gtx/gtx_intersect.cpp
  71. 1
      test/gtx/gtx_io.cpp
  72. 1
      test/gtx/gtx_log_base.cpp
  73. 1
      test/gtx/gtx_matrix_cross_product.cpp
  74. 1
      test/gtx/gtx_matrix_interpolation.cpp
  75. 1
      test/gtx/gtx_matrix_major_storage.cpp
  76. 1
      test/gtx/gtx_matrix_operation.cpp
  77. 1
      test/gtx/gtx_matrix_query.cpp
  78. 1
      test/gtx/gtx_matrix_transform_2d.cpp
  79. 1
      test/gtx/gtx_multiple.cpp
  80. 1
      test/gtx/gtx_norm.cpp
  81. 1
      test/gtx/gtx_normal.cpp
  82. 1
      test/gtx/gtx_normalize_dot.cpp
  83. 1
      test/gtx/gtx_number_precision.cpp
  84. 1
      test/gtx/gtx_optimum_pow.cpp
  85. 1
      test/gtx/gtx_orthonormalize.cpp
  86. 1
      test/gtx/gtx_perpendicular.cpp
  87. 1
      test/gtx/gtx_polar_coordinates.cpp
  88. 1
      test/gtx/gtx_projection.cpp
  89. 1
      test/gtx/gtx_quaternion.cpp
  90. 1
      test/gtx/gtx_rotate_normalized_axis.cpp
  91. 1
      test/gtx/gtx_rotate_vector.cpp
  92. 1
      test/gtx/gtx_scalar_relational.cpp
  93. 1
      test/gtx/gtx_simd_mat4.cpp
  94. 1
      test/gtx/gtx_simd_vec4.cpp
  95. 1
      test/gtx/gtx_spline.cpp
  96. 1
      test/gtx/gtx_string_cast.cpp
  97. 1
      test/gtx/gtx_vector_angle.cpp
  98. 1
      test/gtx/gtx_vector_query.cpp

@ -29,7 +29,6 @@
/// dummy.cpp exist only a wordaround for CMake file.
///////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#define GLM_MESSAGES
#include "../glm.hpp"
#include <limits>

@ -89,7 +89,7 @@ namespace glm
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
///
/// @param m Input matrix multiplied by this rotation matrix.
/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Rotation angle expressed in radians.
/// @param axis Rotation axis, recommanded to be normalized.
/// @tparam T Value type used to build the matrix. Supported: half, float or double.
/// @see gtc_matrix_transform
@ -175,7 +175,7 @@ namespace glm
/// Creates a matrix for a symetric perspective-view frustum.
///
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param fovy Expressed in radians.
/// @param aspect
/// @param near
/// @param far
@ -190,7 +190,7 @@ namespace glm
/// Builds a perspective projection matrix based on a field of view.
///
/// @param fov Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param fov Expressed in radians.
/// @param width
/// @param height
/// @param near
@ -207,7 +207,7 @@ namespace glm
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
///
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param fovy Expressed in radians.
/// @param aspect
/// @param near
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
@ -218,7 +218,7 @@ namespace glm
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
///
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param fovy Expressed in radians.
/// @param aspect
/// @param near
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
@ -229,7 +229,7 @@ namespace glm
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
///
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param fovy Expressed in radians.
/// @param aspect
/// @param near
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.

@ -52,14 +52,9 @@ namespace glm
detail::tvec3<T, P> const & v
)
{
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
# pragma message("GLM: rotate function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tvec3<T, P> axis(normalize(v));
detail::tvec3<T, P> temp((T(1) - c) * axis);
@ -93,14 +88,9 @@ namespace glm
detail::tvec3<T, P> const & v
)
{
#ifdef GLM_FORCE_RADIANS
T const a = angle;
#else
# pragma message("GLM: rotate_slow function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const c = cos(a);
T const s = sin(a);
detail::tmat4x4<T, P> Result;
detail::tvec3<T, P> axis = normalize(v);
@ -226,14 +216,8 @@ namespace glm
assert(aspect != static_cast<T>(0));
assert(zFar != zNear);
#ifdef GLM_FORCE_RADIANS
T const rad = fovy;
#else
# pragma message("GLM: perspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const rad = glm::radians(fovy);
#endif
T tanHalfFovy = tan(rad / static_cast<T>(2));
T const tanHalfFovy = tan(rad / static_cast<T>(2));
detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
@ -258,14 +242,9 @@ namespace glm
assert(height > static_cast<T>(0));
assert(fov > static_cast<T>(0));
#ifdef GLM_FORCE_RADIANS
T rad = fov;
#else
# pragma message("GLM: perspectiveFov function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T rad = glm::radians(fov);
#endif
T h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
T w = h * height / width; ///todo max(width , Height) / min(width , Height)?
T const rad = fov;
T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
Result[0][0] = w;
@ -284,16 +263,11 @@ namespace glm
T zNear
)
{
#ifdef GLM_FORCE_RADIANS
T const range = tan(fovy / T(2)) * zNear;
#else
# pragma message("GLM: infinitePerspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const range = tan(radians(fovy / T(2))) * zNear;
#endif
T left = -range * aspect;
T right = range * aspect;
T bottom = -range;
T top = range;
T const left = -range * aspect;
T const right = range * aspect;
T const bottom = -range;
T const top = range;
detail::tmat4x4<T, defaultp> Result(T(0));
Result[0][0] = (T(2) * zNear) / (right - left);
@ -314,16 +288,11 @@ namespace glm
T ep
)
{
#ifdef GLM_FORCE_RADIANS
T range = tan(fovy / T(2)) * zNear;
#else
# pragma message("GLM: tweakedInfinitePerspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T range = tan(radians(fovy / T(2))) * zNear;
#endif
T left = -range * aspect;
T right = range * aspect;
T bottom = -range;
T top = range;
T const range = tan(fovy / T(2)) * zNear;
T const left = -range * aspect;
T const right = range * aspect;
T const bottom = -range;
T const top = range;
detail::tmat4x4<T, defaultp> Result(T(0));
Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
@ -420,9 +389,9 @@ namespace glm
detail::tvec3<T, P> const & up
)
{
detail::tvec3<T, P> f(normalize(center - eye));
detail::tvec3<T, P> s(normalize(cross(f, up)));
detail::tvec3<T, P> u(cross(s, f));
detail::tvec3<T, P> const f(normalize(center - eye));
detail::tvec3<T, P> const s(normalize(cross(f, up)));
detail::tvec3<T, P> const u(cross(s, f));
detail::tmat4x4<T, P> Result(1);
Result[0][0] = s.x;

@ -247,7 +247,7 @@ namespace detail
/// Rotates a quaternion from a vector of 3 components axis and an angle.
///
/// @param q Source orientation
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param axis Axis of the rotation
///
/// @see gtc_quaternion
@ -265,19 +265,19 @@ namespace detail
GLM_FUNC_DECL detail::tvec3<T, P> eulerAngles(
detail::tquat<T, P> const & x);
/// Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
/// Returns roll value of euler angles expressed in radians.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T roll(detail::tquat<T, P> const & x);
/// Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
/// Returns pitch value of euler angles expressed in radians.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T pitch(detail::tquat<T, P> const & x);
/// Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
/// Returns yaw value of euler angles expressed in radians.
///
/// @see gtx_quaternion
template <typename T, precision P>
@ -326,7 +326,7 @@ namespace detail
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param axis Axis of the quaternion, must be normalized.
///
/// @see gtc_quaternion

@ -615,12 +615,7 @@ namespace detail
Tmp.z *= oneOverLen;
}
#ifdef GLM_FORCE_RADIANS
T const AngleRad(angle);
#else
# pragma message("GLM: rotate function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const AngleRad = radians(angle);
#endif
T const Sin = sin(AngleRad * T(0.5));
return q * detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
@ -642,12 +637,7 @@ namespace detail
detail::tquat<T, P> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return T(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
#else
# pragma message("GLM: roll function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return glm::degrees(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
#endif
}
template <typename T, precision P>
@ -656,12 +646,7 @@ namespace detail
detail::tquat<T, P> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
#else
# pragma message("GLM: pitch function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return glm::degrees(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
#endif
}
template <typename T, precision P>
@ -670,12 +655,7 @@ namespace detail
detail::tquat<T, P> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return asin(T(-2) * (q.x * q.z - q.w * q.y));
#else
# pragma message("GLM: yaw function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return glm::degrees(asin(T(-2) * (q.x * q.z - q.w * q.y)));
#endif
}
template <typename T, precision P>
@ -800,12 +780,7 @@ namespace detail
detail::tquat<T, P> const & x
)
{
#ifdef GLM_FORCE_RADIANS
return acos(x.w) * T(2);
#else
# pragma message("GLM: angle function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return glm::degrees(acos(x.w) * T(2));
#endif
}
template <typename T, precision P>
@ -830,15 +805,10 @@ namespace detail
{
detail::tquat<T, P> result;
#ifdef GLM_FORCE_RADIANS
T const a(angle);
#else
# pragma message("GLM: angleAxis function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const a(glm::radians(angle));
#endif
T s = glm::sin(a * T(0.5));
T const s = glm::sin(a * static_cast<T>(0.5));
result.w = glm::cos(a * T(0.5));
result.w = glm::cos(a * static_cast<T>(0.5));
result.x = v.x * s;
result.y = v.y * s;
result.z = v.z * s;

@ -47,13 +47,9 @@ namespace glm
detail::tmat3x3<T, P> const & m,
T const & angle)
{
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
Result[0] = m[0] * c + m[1] * s;

@ -19,18 +19,10 @@ namespace glm
detail::tvec3<T, P> const tmp(euclidean / Length);
T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
#ifdef GLM_FORCE_RADIANS
return detail::tvec3<T, P>(
atan(xz_dist, tmp.y), // latitude
atan(tmp.x, tmp.z), // longitude
xz_dist); // xz distance
#else
# pragma message("GLM: polar function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return detail::tvec3<T, P>(
degrees(atan(xz_dist, tmp.y)), // latitude
degrees(atan(tmp.x, tmp.z)), // longitude
xz_dist); // xz distance
#endif
}
template <typename T, precision P>
@ -39,14 +31,8 @@ namespace glm
detail::tvec2<T, P> const & polar
)
{
#ifdef GLM_FORCE_RADIANS
T const latitude(polar.x);
T const longitude(polar.y);
#else
# pragma message("GLM: euclidean function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const latitude(radians(polar.x));
T const longitude(radians(polar.y));
#endif
return detail::tvec3<T, P>(
cos(latitude) * sin(longitude),

@ -36,18 +36,13 @@ namespace glm
detail::tvec3<T, P> const & v
)
{
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
# pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tvec3<T, P> axis = v;
detail::tvec3<T, P> const axis(v);
detail::tvec3<T, P> temp = (T(1) - c) * axis;
detail::tvec3<T, P> const temp((static_cast<T>(1) - c) * axis);
detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
Rotate[0][0] = c + temp[0] * axis[0];
@ -78,14 +73,9 @@ namespace glm
detail::tvec3<T, P> const & v
)
{
detail::tvec3<T, P> Tmp = v;
detail::tvec3<T, P> const Tmp(v);
#ifdef GLM_FORCE_RADIANS
T const AngleRad(angle);
#else
# pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const AngleRad = radians(angle);
#endif
T const Sin = sin(AngleRad * T(0.5));
return q * detail::tquat<T, P>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);

@ -296,7 +296,7 @@ namespace detail
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param axis Axis of the quaternion, must be normalized.
///
/// @see gtc_quaternion
@ -306,7 +306,7 @@ namespace detail
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param x x component of the x-axis, x, y, z must be a normalized axis
/// @param y y component of the y-axis, x, y, z must be a normalized axis
/// @param z z component of the z-axis, x, y, z must be a normalized axis

@ -45,6 +45,7 @@ GLM 0.9.6.0: 2014-XX-XX
- Added move contructors and assignment operators (#141)
- Use pragma once
- Fixed Visual Studio 14 compiler warnings
- Added *vec1 support to *vec2 types
================================================================================
GLM 0.9.5.5: 2014-XX-XX

@ -10,7 +10,6 @@
//#include <boost/array.hpp>
//#include <boost/date_time/posix_time/posix_time.hpp>
//#include <boost/thread/thread.hpp>
#define GLM_FORCE_RADIANS
#include <glm/gtc/constants.hpp>
#include <glm/gtc/epsilon.hpp>
#include <cstdio>

@ -7,7 +7,6 @@
// File : test/core/func_exponential.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/common.hpp>
#include <glm/exponential.hpp>
#include <glm/gtc/ulp.hpp>

@ -7,7 +7,6 @@
// File : test/core/func_geometric.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/geometric.hpp>
#include <glm/gtc/epsilon.hpp>

@ -7,7 +7,6 @@
// File : test/core/func_integer.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/integer.hpp>
#include <iostream>

@ -7,7 +7,6 @@
// File : test/core/func_matrix.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/matrix.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/ulp.hpp>

@ -7,8 +7,6 @@
// File : test/core/func_noise.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
int main()
{
int Failed = 0;

@ -7,7 +7,6 @@
// File : test/core/func_packing.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/vector_relational.hpp>

@ -7,7 +7,6 @@
// File : test/core/core_func_swizzle.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#define GLM_MESSAGES
#define GLM_SWIZZLE
#include <glm/glm.hpp>

@ -7,7 +7,6 @@
// File : test/core/func_trigonometric.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/core/vector_relational.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/core/type_cast.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <algorithm>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_float.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
int test_float_size()

@ -7,7 +7,6 @@
// File : test/core/type_int.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
int test_int_size()

@ -7,7 +7,6 @@
// File : test/core/type_length.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
int test_length_mat_non_squared()

@ -7,7 +7,6 @@
// File : test/core/type_mat2x2.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/matrix.hpp>
#include <glm/vector_relational.hpp>

@ -7,7 +7,6 @@
// File : test/core/type_mat2x3.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat2x3.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat2x4.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat2x4.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat3x2.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat3x2.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat3x3.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/matrix.hpp>
#include <glm/vector_relational.hpp>

@ -7,7 +7,6 @@
// File : test/core/type_mat3x4.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat3x4.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat4x2.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat4x2.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat4x3.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/mat4x3.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_mat4x4.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/matrix.hpp>
#include <glm/mat4x4.hpp>

@ -8,7 +8,6 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_SWIZZLE
#define GLM_FORCE_RADIANS
#include <glm/gtx/vec1.hpp>
int test_operators()

@ -8,7 +8,6 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_SWIZZLE
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/vec2.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/core/type_vec3.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#define GLM_SWIZZLE
#include <glm/vector_relational.hpp>
#include <glm/geometric.hpp>

@ -8,7 +8,6 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_SWIZZLE
#define GLM_FORCE_RADIANS
#include <glm/vector_relational.hpp>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/constants.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/constants.hpp>
int test_epsilon()

@ -7,7 +7,6 @@
// File : test/gtc/epsilon.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/gtc/constants.hpp>
#include <glm/vector_relational.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/matrix_access.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_access.hpp>
#include <glm/mat2x2.hpp>
#include <glm/mat2x3.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/matrix_integer.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_integer.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/gtc/matrix_inverse.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_inverse.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/constants.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/noise.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/noise.hpp>
#include <gli/gli.hpp>
#include <gli/gtx/loader.hpp>

@ -26,7 +26,6 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/packing.hpp>
#include <cstdio>
#include <vector>

@ -7,7 +7,6 @@
// File : test/gtc/quaternion.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/quaternion.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/vector_relational.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/random.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/random.hpp>
#include <glm/gtc/epsilon.hpp>
#include <iostream>

@ -7,7 +7,6 @@
// File : test/gtc/reciprocal.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/reciprocal.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/gtc/type_precision.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtc/quaternion.hpp>
#include <vector>

@ -7,7 +7,6 @@
// File : test/gtc/type_ptr.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_ptr.hpp>
int test_value_ptr_vec()

@ -7,7 +7,6 @@
// File : test/gtc/ulp.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/ulp.hpp>
#include <iostream>
#include <limits>

@ -7,7 +7,6 @@
// File : test/gtx/associated_min_max.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/associated_min_max.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/bit.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/bit.hpp>
#include <glm/gtc/type_precision.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/associated_min_max.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/associated_min_max.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/color_space.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/color_space.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/color_space_YCoCg.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/color_space_YCoCg.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/compatibility.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/compatibility.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/component_wise.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/component_wise.hpp>

@ -7,7 +7,6 @@
// File : test/gtc/gtc_dual_quaternion.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/dual_quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/epsilon.hpp>

@ -9,7 +9,6 @@
// Code sample from Filippo Ramaciotti
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/gtx/string_cast.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/extend.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/extend.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/associated_min_max.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/associated_min_max.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/associated_min_max.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/fast_exponential.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/fast_square_root.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/fast_square_root.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtc/epsilon.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/fast_trigonometry.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/fast_trigonometry.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/gradient_paint.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/gradient_paint.hpp>
int test_radialGradient()

@ -7,7 +7,6 @@
// File : test/gtx/handed_coordinate_space.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/handed_coordinate_space.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/inertia.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/inertia.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/gtx_integer.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/gtx/integer.hpp>
#include <cstdio>

@ -7,7 +7,6 @@
// File : test/gtx/intersect.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/intersect.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/io.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/io.hpp>
#include <iostream>

@ -7,7 +7,6 @@
// File : test/gtx/log_base.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/log_base.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/matrix_cross_product.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/matrix_cross_product.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/matrix_interpolation.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/matrix_interpolation.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/gtx/matrix_major_storage.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/matrix_major_storage.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/matrix_operation.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/matrix_operation.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/matrix_query.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/matrix_query.hpp>
int test_isNull()

@ -7,7 +7,6 @@
// File : test/gtx/matrix_transform_2d.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/matrix_transform_2d.hpp>
int main()

@ -7,7 +7,6 @@
// File : test/gtx/gtx_multiple.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtx/multiple.hpp>
int test_higher_int()

@ -7,7 +7,6 @@
// File : test/gtx/norm.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/norm.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/normal.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/normal.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/normalize_dot.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/normalize_dot.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/number_precision.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/number_precision.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/optimum_pow.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/optimum_pow.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/orthonormalize.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/orthonormalize.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/perpendicular.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/perpendicular.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/polar_coordinates.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/polar_coordinates.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/projection.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/projection.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/quaternion.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/epsilon.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>

@ -26,7 +26,6 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/rotate_normalized_axis.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/rotate_vector.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/constants.hpp>
#include <glm/gtx/rotate_vector.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/gtx_scalar_relational.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/scalar_relational.hpp>
#include <cstdio>

@ -7,7 +7,6 @@
// File : test/gtx/simd-mat4.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/simd-vec4.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/simd_vec4.hpp>
#include <cstdio>

@ -7,7 +7,6 @@
// File : test/gtx/associated_min_max.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <glm/gtx/spline.hpp>

@ -7,7 +7,6 @@
// File : test/gtx/string_cast.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>
#include <iostream>

@ -7,7 +7,6 @@
// File : test/gtx/vector_angle.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/gtc/constants.hpp>
#include <glm/gtx/vector_angle.hpp>
#include <iostream>

@ -7,7 +7,6 @@
// File : test/gtx/vector_query.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/vector_query.hpp>

Loading…
Cancel
Save