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

Added GLM_FORCE_RADIANS

Browse Source
master
Christophe Riccio ago%!(EXTRA string=13 years)
parent ebd1ba8bf6
commit 100b2202dd
12 changed files with 237 additions and 92 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      glm/core/setup.hpp
  2. 12
      glm/gtc/matrix_transform.hpp
  3. 26
      glm/gtc/matrix_transform.inl
  4. 4
      glm/gtc/quaternion.hpp
  5. 12
      glm/gtc/quaternion.inl
  6. 20
      glm/gtc/reciprocal.hpp
  7. 4
      glm/gtc/reciprocal.inl
  8. 27
      glm/gtx/polar_coordinates.inl
  9. 114
      glm/gtx/quaternion.hpp
  10. 22
      glm/gtx/quaternion.inl
  11. 73
      glm/gtx/rotate_vector.inl
  12. 10
      glm/gtx/vector_angle.inl

5
glm/core/setup.hpp
Unescape View File

@ -590,6 +590,11 @@
# endif//GLM_MESSAGE_COMPONENT_DISPLAYED
#endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Radians
//#define GLM_FORCE_RADIANS
///////////////////////////////////////////////////////////////////////////////////////////////////
// Static assert

12
glm/gtc/matrix_transform.hpp
Unescape View File

@ -83,10 +83,10 @@ namespace glm
detail::tmat4x4<T> const & m,
detail::tvec3<T> const & v);
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees.
/// 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 degrees.
/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param axis Rotation axis, recommanded to be normalized.
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
@ -172,7 +172,7 @@ namespace glm
/// Creates a matrix for a symetric perspective-view frustum.
///
/// @param fovy
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param aspect
/// @param near
/// @param far
@ -187,7 +187,7 @@ namespace glm
/// Builds a perspective projection matrix based on a field of view.
///
/// @param fov
/// @param fov Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param width
/// @param height
/// @param near
@ -204,7 +204,7 @@ namespace glm
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
///
/// @param fovy
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param aspect
/// @param near
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
@ -215,7 +215,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
/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param aspect
/// @param near
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.

26
glm/gtc/matrix_transform.inl
Unescape View File

@ -48,7 +48,11 @@ namespace glm
detail::tvec3<T> const & v
)
{
T a = radians(angle);
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
@ -120,7 +124,11 @@ namespace glm
detail::tvec3<T> const & v
)
{
T a = radians(angle);
#ifdef GLM_FORCE_RADIANS
T const a = angle;
#else
T const a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
detail::tmat4x4<T> Result;
@ -253,7 +261,11 @@ namespace glm
valType const & zFar
)
{
#ifdef GLM_FORCE_RADIANS
valType rad = fov;
#else
valType rad = glm::radians(fov);
#endif
valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
valType w = h * height / width;
@ -274,7 +286,11 @@ namespace glm
T zNear
)
{
T range = tan(radians(fovy / T(2))) * zNear;
#ifdef GLM_FORCE_RADIANS
T const range = tan(fovy / T(2)) * zNear;
#else
T const range = tan(radians(fovy / T(2))) * zNear;
#endif
T left = -range * aspect;
T right = range * aspect;
T bottom = -range;
@ -297,7 +313,11 @@ namespace glm
T zNear
)
{
#ifdef GLM_FORCE_RADIANS
T range = tan(fovy / T(2)) * zNear;
#else
T range = tan(radians(fovy / T(2))) * zNear;
#endif
T left = -range * aspect;
T right = range * aspect;
T bottom = -range;

4
glm/gtc/quaternion.hpp
Unescape View File

@ -195,7 +195,9 @@ namespace detail
detail::tquat<T> inverse(
detail::tquat<T> const & q);
/// Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
/// Rotates a quaternion from an vector of 3 components axis and an angle.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
///
/// @see gtc_quaternion
template <typename T>

12
glm/gtc/quaternion.inl
Unescape View File

@ -487,10 +487,14 @@ namespace detail
Tmp.z *= oneOverLen;
}
typename detail::tquat<T>::value_type AngleRad = radians(angle);
typename detail::tquat<T>::value_type fSin = sin(AngleRad * T(0.5));
return q * detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin);
#ifdef GLM_FORCE_RADIANS
typename detail::tquat<T>::value_type const AngleRad(angle);
#else
typename detail::tquat<T>::value_type const AngleRad = radians(angle);
#endif
typename detail::tquat<T>::value_type const Sin = sin(AngleRad * T(0.5));
return q * detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
//return gtc::quaternion::cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
}

20
glm/gtc/reciprocal.hpp
Unescape View File

@ -20,29 +20,29 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtx_reciprocal
/// @file glm/gtx/reciprocal.hpp
/// @date 2008-10-09 / 2011-06-07
/// @ref gtc_reciprocal
/// @file glm/gtc/reciprocal.hpp
/// @date 2008-10-09 / 2012-01-25
/// @author Christophe Riccio
///
/// @see core (dependence)
///
/// @defgroup gtx_reciprocal GLM_GTX_reciprocal: Reciprocal
/// @ingroup gtx
/// @defgroup gtc_reciprocal GLM_GTC_reciprocal: Reciprocal
/// @ingroup gtc
///
/// @brief Define secant, cosecant and cotangent functions.
///
/// <glm/gtx/reciprocal.hpp> need to be included to use these functionalities.
/// <glm/gtc/reciprocal.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_reciprocal
#define GLM_GTX_reciprocal GLM_VERSION
#ifndef GLM_GTC_reciprocal
#define GLM_GTC_reciprocal GLM_VERSION
// Dependency:
#include "../glm.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTX_reciprocal extension included")
# pragma message("GLM: GLM_GTC_reciprocal extension included")
#endif
namespace glm
@ -118,4 +118,4 @@ namespace glm
#include "reciprocal.inl"
#endif//GLM_GTX_reciprocal
#endif//GLM_GTC_reciprocal

4
glm/gtc/reciprocal.inl
Unescape View File

@ -2,9 +2,9 @@
// OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-10-09
// Updated : 2011-10-14
// Updated : 2012-01-25
// Licence : This source is under MIT License
// File : glm/gtx/reciprocal.inl
// File : glm/gtc/reciprocal.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "../core/_vectorize.hpp"

27
glm/gtx/polar_coordinates.inl
Unescape View File

@ -15,14 +15,21 @@ namespace glm
detail::tvec3<T> const & euclidean
)
{
T length = length(euclidean);
detail::tvec3<T> tmp = euclidean / length;
T xz_dist = sqrt(tmp.x * tmp.x + tmp.z * tmp.z);
T const Length(length(euclidean));
detail::tvec3<T> 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>(
atan(xz_dist, tmp.y), // latitude
atan(tmp.x, tmp.z), // longitude
xz_dist); // xz distance
#else
return detail::tvec3<T>(
degrees(atan(xz_dist, tmp.y)), // latitude
degrees(atan(tmp.x, tmp.z)), // longitude
xz_dist); // xz distance
degrees(atan(tmp.x, tmp.z)), // longitude
xz_dist); // xz distance
#endif
}
template <typename T>
@ -31,8 +38,14 @@ namespace glm
detail::tvec3<T> const & polar
)
{
T latitude = radians(polar.x);
T longitude = radians(polar.y);
#ifdef GLM_FORCE_RADIANS
T const latitude(polar.x);
T const longitude(polar.y);
#else
T const latitude(radians(polar.x));
T const longitude(radians(polar.y));
#endif
return detail::tvec3<T>(
cos(latitude) * sin(longitude),
sin(latitude),

114
glm/gtx/quaternion.hpp
Unescape View File

@ -53,14 +53,16 @@ namespace glm
/// @{
//! Compute a cross product between a quaternion and a vector.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec3<valType> cross(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Compute a cross product between a vector and a quaternion.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec3<valType> cross(
detail::tvec3<valType> const & v,
@ -68,7 +70,8 @@ namespace glm
//! Compute a point on a path according squad equation.
//! q1 and q2 are control points; s1 and s2 are intermediate control points.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> squad(
detail::tquat<valType> const & q1,
@ -78,7 +81,8 @@ namespace glm
valType const & h);
//! Returns an intermediate control point for squad interpolation.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> intermediate(
detail::tquat<valType> const & prev,
@ -86,59 +90,70 @@ namespace glm
detail::tquat<valType> const & next);
//! Returns a exp of a quaternion.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> exp(
detail::tquat<valType> const & q,
valType const & exponent);
//! Returns a log of a quaternion.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> log(
detail::tquat<valType> const & q);
//! Returns x raised to the y power.
//! From GLM_GTX_quaternion extension.
/// Returns x raised to the y power.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> pow(
detail::tquat<valType> const & x,
valType const & y);
//! Returns quarternion square root.
//! From GLM_GTX_quaternion extension.
///
/// @see gtx_quaternion
//template <typename valType>
//detail::tquat<valType> sqrt(
// detail::tquat<valType> const & q);
//! Rotates a 3 components vector by a quaternion.
//! From GLM_GTX_transform extension.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec3<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Rotates a 4 components vector by a quaternion.
//! From GLM_GTX_transform extension.
/// Rotates a 4 components vector by a quaternion.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec4<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec4<valType> const & v);
//! Returns the quaternion rotation angle.
//! From GLM_GTX_quaternion extension.
/// Returns the quaternion rotation angle.
///
/// @see gtx_quaternion
template <typename valType>
valType angle(
detail::tquat<valType> const & x);
//! Returns the q rotation axis.
//! From GLM_GTX_quaternion extension.
/// Returns the q rotation axis.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec3<valType> axis(
detail::tquat<valType> const & x);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
/// 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.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
@ -146,77 +161,92 @@ namespace glm
valType const & y,
valType const & z);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
/// 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 axis Axis of the quaternion, must be normalized.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
detail::tvec3<valType> const & axis);
//! Extract the real component of a quaternion.
//! From GLM_GTX_quaternion extension.
/// Extract the real component of a quaternion.
///
/// @see gtx_quaternion
template <typename valType>
valType extractRealComponent(
detail::tquat<valType> const & q);
//! Returns roll value of euler angles in degrees.
//! From GLM_GTX_quaternion extension.
/// Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
///
/// @see gtx_quaternion
template <typename valType>
valType roll(
detail::tquat<valType> const & x);
//! Returns pitch value of euler angles in degrees.
//! From GLM_GTX_quaternion extension.
/// Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
///
/// @see gtx_quaternion
template <typename valType>
valType pitch(
detail::tquat<valType> const & x);
//! Returns yaw value of euler angles in degrees.
//! From GLM_GTX_quaternion extension.
/// Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
///
/// @see gtx_quaternion
template <typename valType>
valType yaw(
detail::tquat<valType> const & x);
//! Returns euler angles, yitch as x, yaw as y, roll as z.
//! From GLM_GTX_quaternion extension.
/// Returns euler angles, yitch as x, yaw as y, roll as z.
///
/// @see gtx_quaternion
template <typename valType>
detail::tvec3<valType> eulerAngles(
detail::tquat<valType> const & x);
//! Converts a quaternion to a 3 * 3 matrix.
//! From GLM_GTX_quaternion extension.
/// Converts a quaternion to a 3 * 3 matrix.
///
/// @see gtx_quaternion
template <typename valType>
detail::tmat3x3<valType> toMat3(
detail::tquat<valType> const & x){return mat3_cast(x);}
//! Converts a quaternion to a 4 * 4 matrix.
//! From GLM_GTX_quaternion extension.
/// Converts a quaternion to a 4 * 4 matrix.
///
/// @see gtx_quaternion
template <typename valType>
detail::tmat4x4<valType> toMat4(
detail::tquat<valType> const & x){return mat4_cast(x);}
//! Converts a 3 * 3 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
/// Converts a 3 * 3 matrix to a quaternion.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat3x3<valType> const & x){return quat_cast(x);}
//! Converts a 4 * 4 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
/// Converts a 4 * 4 matrix to a quaternion.
///
/// @see gtx_quaternion
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat4x4<valType> const & x){return quat_cast(x);}
//! Quaternion interpolation using the rotation short path.
//! From GLM_GTX_quaternion extension.
/// Quaternion interpolation using the rotation short path.
///
/// @see gtx_quaternion
template <typename T>
detail::tquat<T> shortMix(
detail::tquat<T> const & x,
detail::tquat<T> const & y,
T const & a);
//! Quaternion normalized linear interpolation.
//! From GLM_GTX_quaternion extension.
/// Quaternion normalized linear interpolation.
///
/// @see gtx_quaternion
template <typename T>
detail::tquat<T> fastMix(
detail::tquat<T> const & x,

22
glm/gtx/quaternion.inl
Unescape View File

@ -147,7 +147,11 @@ namespace glm
detail::tquat<T> const & x
)
{
#ifdef GLM_FORCE_RADIANS
return acos(x.w) * T(2);
#else
return glm::degrees(acos(x.w) * T(2));
#endif
}
template <typename T>
@ -184,7 +188,11 @@ namespace glm
{
detail::tquat<valType> result;
valType a = glm::radians(angle);
#ifdef GLM_FORCE_RADIANS
valType a(angle);
#else
valType a(glm::radians(angle));
#endif
valType s = glm::sin(a * valType(0.5));
result.w = glm::cos(a * valType(0.5));
@ -213,7 +221,11 @@ namespace glm
detail::tquat<valType> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return atan2(valType(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
return glm::degrees(atan2(valType(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 valType>
@ -222,7 +234,11 @@ namespace glm
detail::tquat<valType> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return atan2(valType(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
return glm::degrees(atan2(valType(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 valType>
@ -231,7 +247,11 @@ namespace glm
detail::tquat<valType> const & q
)
{
#ifdef GLM_FORCE_RADIANS
return asin(valType(-2) * (q.x * q.z - q.w * q.y));
#else
return glm::degrees(asin(valType(-2) * (q.x * q.z - q.w * q.y)));
#endif
}
template <typename valType>

73
glm/gtx/rotate_vector.inl
Unescape View File

@ -17,8 +17,13 @@ namespace glm
)
{
detail::tvec2<T> Result;
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos = cos(radians(angle));
T const Sin = sin(radians(angle));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
return Result;
@ -64,9 +69,16 @@ namespace glm
T const & angle
)
{
detail::tvec3<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
detail::tvec3<T> Result(v);
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos = cos(radians(angle));
T const Sin = sin(radians(angle));
#endif
Result.y = v.y * Cos - v.z * Sin;
Result.z = v.y * Sin + v.z * Cos;
return Result;
@ -80,8 +92,15 @@ namespace glm
)
{
detail::tvec3<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos + v.z * Sin;
Result.z = -v.x * Sin + v.z * Cos;
return Result;
@ -95,8 +114,15 @@ namespace glm
)
{
detail::tvec3<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
return Result;
@ -110,8 +136,15 @@ namespace glm
)
{
detail::tvec4<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.y = v.y * Cos - v.z * Sin;
Result.z = v.y * Sin + v.z * Cos;
return Result;
@ -125,8 +158,15 @@ namespace glm
)
{
detail::tvec4<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos + v.z * Sin;
Result.z = -v.x * Sin + v.z * Cos;
return Result;
@ -140,8 +180,15 @@ namespace glm
)
{
detail::tvec4<T> Result = v;
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
#ifdef GLM_FORCE_RADIANS
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
return Result;

10
glm/gtx/vector_angle.inl
Unescape View File

@ -27,8 +27,12 @@ namespace glm
detail::tvec2<valType> const & y
)
{
valType Angle = glm::degrees(acos(dot(x, y)));
detail::tvec2<valType> TransformedVector = glm::rotate(x, Angle);
#ifdef GLM_FORCE_RADIANS
valType const Angle(acos(dot(x, y)));
#else
valType const Angle(glm::degrees(acos(dot(x, y))));
#endif
detail::tvec2<valType> const TransformedVector(glm::rotate(x, Angle));
if(all(equalEpsilon(y, TransformedVector, valType(0.01))))
return Angle;
else
@ -43,7 +47,7 @@ namespace glm
detail::tvec3<valType> const & ref
)
{
valType Angle = glm::degrees(glm::acos(glm::dot(x, y)));
valType const Angle(glm::degrees(glm::acos(glm::dot(x, y))));
if(glm::dot(ref, glm::cross(x, y)) < valType(0))
return -Angle;

Write Preview
Loading…
Cancel
Save