organicmaps/glm
13
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2025-04-05 13:35:03 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

- Moved template types from 'detail' to 'glm' namespace #239, #244

Browse source
This commit is contained in:
Christophe Riccio 2014-10-05 19:37:07 +02:00
parent 4ac77c08c7
commit f9484a6e9f
143 changed files with 3859 additions and 3936 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
glm/detail/_noise.hpp
View file

@ -74,19 +74,19 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
@ -99,19 +99,19 @@ namespace detail
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}

88
glm/detail/_vectorize.hpp
View file

@ -35,29 +35,29 @@
#define VECTORIZE1_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func( \
detail::tvec1<T, P> const & v) \
GLM_FUNC_QUALIFIER tvec1<T, P> func( \
tvec1<T, P> const & v) \
{ \
return detail::tvec1<T, P>( \
return tvec1<T, P>( \
func(v.x)); \
}
#define VECTORIZE2_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func( \
detail::tvec2<T, P> const & v) \
GLM_FUNC_QUALIFIER tvec2<T, P> func( \
tvec2<T, P> const & v) \
{ \
return detail::tvec2<T, P>( \
return tvec2<T, P>( \
func(v.x), \
func(v.y)); \
}
#define VECTORIZE3_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func( \
detail::tvec3<T, P> const & v) \
GLM_FUNC_QUALIFIER tvec3<T, P> func( \
tvec3<T, P> const & v) \
{ \
return detail::tvec3<T, P>( \
return tvec3<T, P>( \
func(v.x), \
func(v.y), \
func(v.z)); \
@ -65,10 +65,10 @@
#define VECTORIZE4_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func( \
detail::tvec4<T, P> const & v) \
GLM_FUNC_QUALIFIER tvec4<T, P> func( \
tvec4<T, P> const & v) \
{ \
return detail::tvec4<T, P>( \
return tvec4<T, P>( \
func(v.x), \
func(v.y), \
func(v.z), \
@ -83,38 +83,38 @@
#define VECTORIZE1_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func \
GLM_FUNC_QUALIFIER tvec1<T, P> func \
( \
detail::tvec1<T, P> const & x, \
typename detail::tvec1<T, P>::value_type const & y \
tvec1<T, P> const & x, \
typename tvec1<T, P>::value_type const & y \
) \
{ \
return detail::tvec1<T, P>( \
return tvec1<T, P>( \
func(x.x, y)); \
}
#define VECTORIZE2_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \
GLM_FUNC_QUALIFIER tvec2<T, P> func \
( \
detail::tvec2<T, P> const & x, \
typename detail::tvec2<T, P>::value_type const & y \
tvec2<T, P> const & x, \
typename tvec2<T, P>::value_type const & y \
) \
{ \
return detail::tvec2<T, P>( \
return tvec2<T, P>( \
func(x.x, y), \
func(x.y, y)); \
}
#define VECTORIZE3_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func \
GLM_FUNC_QUALIFIER tvec3<T, P> func \
( \
detail::tvec3<T, P> const & x, \
typename detail::tvec3<T, P>::value_type const & y \
tvec3<T, P> const & x, \
typename tvec3<T, P>::value_type const & y \
) \
{ \
return detail::tvec3<T, P>( \
return tvec3<T, P>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y)); \
@ -122,13 +122,13 @@
#define VECTORIZE4_VEC_SCA(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func \
GLM_FUNC_QUALIFIER tvec4<T, P> func \
( \
detail::tvec4<T, P> const & x, \
typename detail::tvec4<T, P>::value_type const & y \
tvec4<T, P> const & x, \
typename tvec4<T, P>::value_type const & y \
) \
{ \
return detail::tvec4<T, P>( \
return tvec4<T, P>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y), \
@ -143,38 +143,38 @@
#define VECTORIZE1_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec1<T, P> func \
GLM_FUNC_QUALIFIER tvec1<T, P> func \
( \
detail::tvec1<T, P> const & x, \
detail::tvec1<T, P> const & y \
tvec1<T, P> const & x, \
tvec1<T, P> const & y \
) \
{ \
return detail::tvec1<T, P>( \
return tvec1<T, P>( \
func(x.x, y.x)); \
}
#define VECTORIZE2_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec2<T, P> func \
GLM_FUNC_QUALIFIER tvec2<T, P> func \
( \
detail::tvec2<T, P> const & x, \
detail::tvec2<T, P> const & y \
tvec2<T, P> const & x, \
tvec2<T, P> const & y \
) \
{ \
return detail::tvec2<T, P>( \
return tvec2<T, P>( \
func(x.x, y.x), \
func(x.y, y.y)); \
}
#define VECTORIZE3_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec3<T, P> func \
GLM_FUNC_QUALIFIER tvec3<T, P> func \
( \
detail::tvec3<T, P> const & x, \
detail::tvec3<T, P> const & y \
tvec3<T, P> const & x, \
tvec3<T, P> const & y \
) \
{ \
return detail::tvec3<T, P>( \
return tvec3<T, P>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z)); \
@ -182,13 +182,13 @@
#define VECTORIZE4_VEC_VEC(func) \
template <typename T, precision P> \
GLM_FUNC_QUALIFIER detail::tvec4<T, P> func \
GLM_FUNC_QUALIFIER tvec4<T, P> func \
( \
detail::tvec4<T, P> const & x, \
detail::tvec4<T, P> const & y \
tvec4<T, P> const & x, \
tvec4<T, P> const & y \
) \
{ \
return detail::tvec4<T, P>( \
return tvec4<T, P>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z), \

240
glm/detail/func_common.inl
View file

@ -312,49 +312,49 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec1<T, P> modf
GLM_FUNC_QUALIFIER tvec1<T, P> modf
(
detail::tvec1<T, P> const & x,
detail::tvec1<T, P> & i
tvec1<T, P> const & x,
tvec1<T, P> & i
)
{
return detail::tvec1<T, P>(
return tvec1<T, P>(
modf(x.x, i.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> modf
GLM_FUNC_QUALIFIER tvec2<T, P> modf
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> & i
tvec2<T, P> const & x,
tvec2<T, P> & i
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
modf(x.x, i.x),
modf(x.y, i.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> modf
GLM_FUNC_QUALIFIER tvec3<T, P> modf
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> & i
tvec3<T, P> const & x,
tvec3<T, P> & i
)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
modf(x.x, i.x),
modf(x.y, i.y),
modf(x.z, i.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> modf
GLM_FUNC_QUALIFIER tvec4<T, P> modf
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> & i
tvec4<T, P> const & x,
tvec4<T, P> & i
)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
modf(x.x, i.x),
modf(x.y, i.y),
modf(x.z, i.z),
@ -422,9 +422,9 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
GLM_FUNC_QUALIFIER tvec2<T, P> clamp
(
detail::tvec2<T, P> const & x,
tvec2<T, P> const & x,
T const & minVal,
T const & maxVal
)
@ -433,15 +433,15 @@ namespace detail
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
GLM_FUNC_QUALIFIER tvec3<T, P> clamp
(
detail::tvec3<T, P> const & x,
tvec3<T, P> const & x,
T const & minVal,
T const & maxVal
)
@ -450,16 +450,16 @@ namespace detail
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal),
clamp(x.z, minVal, maxVal));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
GLM_FUNC_QUALIFIER tvec4<T, P> clamp
(
detail::tvec4<T, P> const & x,
tvec4<T, P> const & x,
T const & minVal,
T const & maxVal
)
@ -468,7 +468,7 @@ namespace detail
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
clamp(x.x, minVal, maxVal),
clamp(x.y, minVal, maxVal),
clamp(x.z, minVal, maxVal),
@ -476,53 +476,53 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
GLM_FUNC_QUALIFIER tvec2<T, P> clamp
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> const & minVal,
detail::tvec2<T, P> const & maxVal
tvec2<T, P> const & x,
tvec2<T, P> const & minVal,
tvec2<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
GLM_FUNC_QUALIFIER tvec3<T, P> clamp
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & minVal,
detail::tvec3<T, P> const & maxVal
tvec3<T, P> const & x,
tvec3<T, P> const & minVal,
tvec3<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y),
clamp(x.z, minVal.z, maxVal.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
GLM_FUNC_QUALIFIER tvec4<T, P> clamp
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> const & minVal,
detail::tvec4<T, P> const & maxVal
tvec4<T, P> const & x,
tvec4<T, P> const & minVal,
tvec4<T, P> const & maxVal
)
{
GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
"'clamp' only accept floating-point or integer inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
clamp(x.x, minVal.x, maxVal.x),
clamp(x.y, minVal.y, maxVal.y),
clamp(x.z, minVal.z, maxVal.z),
@ -601,47 +601,47 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec2<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec3<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y),
smoothstep(edge0, edge1, x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec4<T, P> smoothstep
(
T const & edge0,
T const & edge1,
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
smoothstep(edge0, edge1, x.x),
smoothstep(edge0, edge1, x.y),
smoothstep(edge0, edge1, x.z),
@ -649,47 +649,47 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec2<T, P> smoothstep
(
detail::tvec2<T, P> const & edge0,
detail::tvec2<T, P> const & edge1,
detail::tvec2<T, P> const & x
tvec2<T, P> const & edge0,
tvec2<T, P> const & edge1,
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec3<T, P> smoothstep
(
detail::tvec3<T, P> const & edge0,
detail::tvec3<T, P> const & edge1,
detail::tvec3<T, P> const & x
tvec3<T, P> const & edge0,
tvec3<T, P> const & edge1,
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y),
smoothstep(edge0.z, edge1.z, x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
GLM_FUNC_QUALIFIER tvec4<T, P> smoothstep
(
detail::tvec4<T, P> const & edge0,
detail::tvec4<T, P> const & edge1,
detail::tvec4<T, P> const & x
tvec4<T, P> const & edge0,
tvec4<T, P> const & edge1,
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
smoothstep(edge0.x, edge1.x, x.x),
smoothstep(edge0.y, edge1.y, x.y),
smoothstep(edge0.z, edge1.z, x.z),
@ -720,53 +720,53 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isnan
GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isnan
(
detail::tvec1<T, P> const & x
tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
return typename detail::tvec1<T, P>::bool_type(
return typename tvec1<T, P>::bool_type(
isnan(x.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isnan
GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isnan
(
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type(
return typename tvec2<T, P>::bool_type(
isnan(x.x),
isnan(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isnan
GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isnan
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
return typename detail::tvec3<T, P>::bool_type(
return typename tvec3<T, P>::bool_type(
isnan(x.x),
isnan(x.y),
isnan(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isnan
GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isnan
(
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
return typename detail::tvec4<T, P>::bool_type(
return typename tvec4<T, P>::bool_type(
isnan(x.x),
isnan(x.y),
isnan(x.z),
@ -798,53 +798,53 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isinf
GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isinf
(
detail::tvec1<T, P> const & x
tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
return typename detail::tvec1<T, P>::bool_type(
return typename tvec1<T, P>::bool_type(
isinf(x.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isinf
GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isinf
(
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type(
return typename tvec2<T, P>::bool_type(
isinf(x.x),
isinf(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isinf
GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isinf
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
return typename detail::tvec3<T, P>::bool_type(
return typename tvec3<T, P>::bool_type(
isinf(x.x),
isinf(x.y),
isinf(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isinf
GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isinf
(
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
return typename detail::tvec4<T, P>::bool_type(
return typename tvec4<T, P>::bool_type(
isinf(x.x),
isinf(x.y),
isinf(x.z),
@ -919,56 +919,56 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec1<T, P> frexp
GLM_FUNC_QUALIFIER tvec1<T, P> frexp
(
detail::tvec1<T, P> const & x,
detail::tvec1<int, P> & exp
tvec1<T, P> const & x,
tvec1<int, P> & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
return detail::tvec1<T, P>(std::frexp(x.x, exp.x));
return tvec1<T, P>(std::frexp(x.x, exp.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> frexp
GLM_FUNC_QUALIFIER tvec2<T, P> frexp
(
detail::tvec2<T, P> const & x,
detail::tvec2<int, P> & exp
tvec2<T, P> const & x,
tvec2<int, P> & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
frexp(x.x, exp.x),
frexp(x.y, exp.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> frexp
GLM_FUNC_QUALIFIER tvec3<T, P> frexp
(
detail::tvec3<T, P> const & x,
detail::tvec3<int, P> & exp
tvec3<T, P> const & x,
tvec3<int, P> & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
frexp(x.x, exp.x),
frexp(x.y, exp.y),
frexp(x.z, exp.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> frexp
GLM_FUNC_QUALIFIER tvec4<T, P> frexp
(
detail::tvec4<T, P> const & x,
detail::tvec4<int, P> & exp
tvec4<T, P> const & x,
tvec4<int, P> & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
frexp(x.x, exp.x),
frexp(x.y, exp.y),
frexp(x.z, exp.z),
@ -988,57 +988,57 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec1<T, P> ldexp
GLM_FUNC_QUALIFIER tvec1<T, P> ldexp
(
detail::tvec1<T, P> const & x,
detail::tvec1<int, P> const & exp
tvec1<T, P> const & x,
tvec1<int, P> const & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
return detail::tvec1<T, P>(
return tvec1<T, P>(
ldexp(x.x, exp.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> ldexp
GLM_FUNC_QUALIFIER tvec2<T, P> ldexp
(
detail::tvec2<T, P> const & x,
detail::tvec2<int, P> const & exp
tvec2<T, P> const & x,
tvec2<int, P> const & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
return detail::tvec2<T, P>(
return tvec2<T, P>(
ldexp(x.x, exp.x),
ldexp(x.y, exp.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> ldexp
GLM_FUNC_QUALIFIER tvec3<T, P> ldexp
(
detail::tvec3<T, P> const & x,
detail::tvec3<int, P> const & exp
tvec3<T, P> const & x,
tvec3<int, P> const & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
ldexp(x.x, exp.x),
ldexp(x.y, exp.y),
ldexp(x.z, exp.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> ldexp
GLM_FUNC_QUALIFIER tvec4<T, P> ldexp
(
detail::tvec4<T, P> const & x,
detail::tvec4<int, P> const & exp
tvec4<T, P> const & x,
tvec4<int, P> const & exp
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
return detail::tvec4<T, P>(
return tvec4<T, P>(
ldexp(x.x, exp.x),
ldexp(x.y, exp.y),
ldexp(x.z, exp.z),

32
glm/detail/func_exponential.inl
View file

@ -173,38 +173,38 @@ namespace detail
struct compute_sqrt{};
template <typename T, precision P>
struct compute_sqrt<detail::tvec1, T, P>
struct compute_sqrt<tvec1, T, P>
{
GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
GLM_FUNC_QUALIFIER static tvec1<T, P> call(tvec1<T, P> const & x)
{
return detail::tvec1<T, P>(std::sqrt(x.x));
return tvec1<T, P>(std::sqrt(x.x));
}
};
template <typename T, precision P>
struct compute_sqrt<detail::tvec2, T, P>
struct compute_sqrt<tvec2, T, P>
{
GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER static tvec2<T, P> call(tvec2<T, P> const & x)
{
return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
return tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
}
};
template <typename T, precision P>
struct compute_sqrt<detail::tvec3, T, P>
struct compute_sqrt<tvec3, T, P>
{
GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER static tvec3<T, P> call(tvec3<T, P> const & x)
{
return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
return tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
}
};
template <typename T, precision P>
struct compute_sqrt<detail::tvec4, T, P>
struct compute_sqrt<tvec4, T, P>
{
GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & x)
{
return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
return tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
}
};
}//namespace detail
@ -215,20 +215,20 @@ namespace detail
GLM_FUNC_QUALIFIER float sqrt(float x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<float, highp> tmp(detail::compute_sqrt<detail::tvec1, float, highp>::call(x));
tvec1<float, highp> tmp(detail::compute_sqrt<tvec1, float, highp>::call(x));
return tmp.x;
# else
return detail::compute_sqrt<detail::tvec1, float, highp>::call(x).x;
return detail::compute_sqrt<tvec1, float, highp>::call(x).x;
# endif
}
GLM_FUNC_QUALIFIER double sqrt(double x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<double, highp> tmp(detail::compute_sqrt<detail::tvec1, double, highp>::call(x));
tvec1<double, highp> tmp(detail::compute_sqrt<tvec1, double, highp>::call(x));
return tmp.x;
# else
return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
return detail::compute_sqrt<tvec1, double, highp>::call(x).x;
# endif
}
*/

6
glm/detail/func_geometric.hpp
View file

@ -92,9 +92,9 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
GLM_FUNC_DECL tvec3<T, P> cross(
tvec3<T, P> const & x,
tvec3<T, P> const & y);
/// Returns a vector in the same direction as x but with length of 1.
///

66
glm/detail/func_geometric.inl
View file

@ -39,45 +39,45 @@ namespace detail
struct compute_dot{};
template <typename T, precision P>
struct compute_dot<detail::tvec1, T, P>
struct compute_dot<tvec1, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & x, tvec1<T, P> const & y)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<T, P> tmp(x * y);
tvec1<T, P> tmp(x * y);
return tmp.x;
# else
return detail::tvec1<T, P>(x * y).x;
return tvec1<T, P>(x * y).x;
# endif
}
};
template <typename T, precision P>
struct compute_dot<detail::tvec2, T, P>
struct compute_dot<tvec2, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
{
detail::tvec2<T, P> tmp(x * y);
tvec2<T, P> tmp(x * y);
return tmp.x + tmp.y;
}
};
template <typename T, precision P>
struct compute_dot<detail::tvec3, T, P>
struct compute_dot<tvec3, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
{
detail::tvec3<T, P> tmp(x * y);
tvec3<T, P> tmp(x * y);
return tmp.x + tmp.y + tmp.z;
}
};
template <typename T, precision P>
struct compute_dot<detail::tvec4, T, P>
struct compute_dot<tvec4, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
{
detail::tvec4<T, P> tmp(x * y);
tvec4<T, P> tmp(x * y);
return (tmp.x + tmp.y) + (tmp.z + tmp.w);
}
};
@ -96,7 +96,7 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER T length(tvec2<T, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
@ -105,7 +105,7 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length(detail::tvec3<T, P> const & v)
GLM_FUNC_QUALIFIER T length(tvec3<T, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
@ -114,7 +114,7 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length(detail::tvec4<T, P> const & v)
GLM_FUNC_QUALIFIER T length(tvec4<T, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
@ -138,8 +138,8 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance
(
detail::tvec2<T, P> const & p0,
detail::tvec2<T, P> const & p1
tvec2<T, P> const & p0,
tvec2<T, P> const & p1
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@ -150,8 +150,8 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance
(
detail::tvec3<T, P> const & p0,
detail::tvec3<T, P> const & p1
tvec3<T, P> const & p0,
tvec3<T, P> const & p1
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@ -162,8 +162,8 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance
(
detail::tvec4<T, P> const & p0,
detail::tvec4<T, P> const & p1
tvec4<T, P> const & p0,
tvec4<T, P> const & p1
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@ -180,7 +180,7 @@ namespace detail
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
return detail::compute_dot<tvec1, T, highp>::call(x, y);
}
template <typename T, precision P, template <typename, precision> class vecType>
@ -213,15 +213,15 @@ namespace detail
*/
// cross
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
GLM_FUNC_QUALIFIER tvec3<T, P> cross
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y
tvec3<T, P> const & x,
tvec3<T, P> const & y
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
return detail::tvec3<T, P>(
return tvec3<T, P>(
x.y * y.z - y.y * x.z,
x.z * y.x - y.z * x.x,
x.x * y.y - y.x * x.y);
@ -241,9 +241,9 @@ namespace detail
// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> normalize
GLM_FUNC_QUALIFIER tvec2<T, P> normalize
(
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
@ -253,9 +253,9 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> normalize
GLM_FUNC_QUALIFIER tvec3<T, P> normalize
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
@ -265,9 +265,9 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> normalize
GLM_FUNC_QUALIFIER tvec4<T, P> normalize
(
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");

96
glm/detail/func_integer.inl
View file

@ -300,41 +300,41 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
GLM_FUNC_QUALIFIER tvec2<T, P> bitfieldExtract
(
detail::tvec2<T, P> const & Value,
tvec2<T, P> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldExtract
GLM_FUNC_QUALIFIER tvec3<T, P> bitfieldExtract
(
detail::tvec3<T, P> const & Value,
tvec3<T, P> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits),
bitfieldExtract(Value[2], Offset, Bits));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldExtract
GLM_FUNC_QUALIFIER tvec4<T, P> bitfieldExtract
(
detail::tvec4<T, P> const & Value,
tvec4<T, P> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits),
bitfieldExtract(Value[2], Offset, Bits),
@ -365,44 +365,44 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldInsert
GLM_FUNC_QUALIFIER tvec2<T, P> bitfieldInsert
(
detail::tvec2<T, P> const & Base,
detail::tvec2<T, P> const & Insert,
tvec2<T, P> const & Base,
tvec2<T, P> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldInsert
GLM_FUNC_QUALIFIER tvec3<T, P> bitfieldInsert
(
detail::tvec3<T, P> const & Base,
detail::tvec3<T, P> const & Insert,
tvec3<T, P> const & Base,
tvec3<T, P> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits),
bitfieldInsert(Base[2], Insert[2], Offset, Bits));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldInsert
GLM_FUNC_QUALIFIER tvec4<T, P> bitfieldInsert
(
detail::tvec4<T, P> const & Base,
detail::tvec4<T, P> const & Insert,
tvec4<T, P> const & Base,
tvec4<T, P> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits),
bitfieldInsert(Base[2], Insert[2], Offset, Bits),
@ -441,35 +441,35 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
GLM_FUNC_QUALIFIER tvec2<int, P> bitCount
(
detail::tvec2<T, P> const & value
tvec2<T, P> const & value
)
{
return detail::tvec2<int, P>(
return tvec2<int, P>(
bitCount(value[0]),
bitCount(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
GLM_FUNC_QUALIFIER tvec3<int, P> bitCount
(
detail::tvec3<T, P> const & value
tvec3<T, P> const & value
)
{
return detail::tvec3<int, P>(
return tvec3<int, P>(
bitCount(value[0]),
bitCount(value[1]),
bitCount(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<int, P> bitCount
GLM_FUNC_QUALIFIER tvec4<int, P> bitCount
(
detail::tvec4<T, P> const & value
tvec4<T, P> const & value
)
{
return detail::tvec4<int, P>(
return tvec4<int, P>(
bitCount(value[0]),
bitCount(value[1]),
bitCount(value[2]),
@ -493,35 +493,35 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
GLM_FUNC_QUALIFIER tvec2<int, P> findLSB
(
detail::tvec2<T, P> const & value
tvec2<T, P> const & value
)
{
return detail::tvec2<int, P>(
return tvec2<int, P>(
findLSB(value[0]),
findLSB(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<int, P> findLSB
GLM_FUNC_QUALIFIER tvec3<int, P> findLSB
(
detail::tvec3<T, P> const & value
tvec3<T, P> const & value
)
{
return detail::tvec3<int, P>(
return tvec3<int, P>(
findLSB(value[0]),
findLSB(value[1]),
findLSB(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<int, P> findLSB
GLM_FUNC_QUALIFIER tvec4<int, P> findLSB
(
detail::tvec4<T, P> const & value
tvec4<T, P> const & value
)
{
return detail::tvec4<int, P>(
return tvec4<int, P>(
findLSB(value[0]),
findLSB(value[1]),
findLSB(value[2]),
@ -617,35 +617,35 @@ namespace glm
#endif//(GLM_COMPILER)
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<int, P> findMSB
GLM_FUNC_QUALIFIER tvec2<int, P> findMSB
(
detail::tvec2<T, P> const & value
tvec2<T, P> const & value
)
{
return detail::tvec2<int, P>(
return tvec2<int, P>(
findMSB(value[0]),
findMSB(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
GLM_FUNC_QUALIFIER tvec3<int, P> findMSB
(
detail::tvec3<T, P> const & value
tvec3<T, P> const & value
)
{
return detail::tvec3<int, P>(
return tvec3<int, P>(
findMSB(value[0]),
findMSB(value[1]),
findMSB(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<int, P> findMSB
GLM_FUNC_QUALIFIER tvec4<int, P> findMSB
(
detail::tvec4<T, P> const & value
tvec4<T, P> const & value
)
{
return detail::tvec4<int, P>(
return tvec4<int, P>(
findMSB(value[0]),
findMSB(value[1]),
findMSB(value[2]),

124
glm/detail/func_matrix.inl
View file

@ -41,11 +41,11 @@ namespace detail
struct compute_outerProduct{};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec2, detail::tvec2, T, P>
struct compute_outerProduct<tvec2, tvec2, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec2>::type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec2>::type call(tvec2<T, P> const & c, tvec2<T, P> const & r)
{
detail::tmat2x2<T, P> m(detail::tmat2x2<T, P>::_null);
tmat2x2<T, P> m(tmat2x2<T, P>::_null);
m[0][0] = c[0] * r[0];
m[0][1] = c[1] * r[0];
m[1][0] = c[0] * r[1];
@ -55,11 +55,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec3, detail::tvec3, T, P>
struct compute_outerProduct<tvec3, tvec3, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec3>::type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec3>::type call(tvec3<T, P> const & c, tvec3<T, P> const & r)
{
detail::tmat3x3<T, P> m(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> m(tmat3x3<T, P>::_null);
for(length_t i(0); i < m.length(); ++i)
m[i] = c * r[i];
return m;
@ -67,11 +67,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec4, detail::tvec4, T, P>
struct compute_outerProduct<tvec4, tvec4, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec4>::type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec4>::type call(tvec4<T, P> const & c, tvec4<T, P> const & r)
{
detail::tmat4x4<T, P> m(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> m(tmat4x4<T, P>::_null);
for(length_t i(0); i < m.length(); ++i)
m[i] = c * r[i];
return m;
@ -79,11 +79,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec3, detail::tvec2, T, P>
struct compute_outerProduct<tvec3, tvec2, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec2>::type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec2>::type call(tvec3<T, P> const & c, tvec2<T, P> const & r)
{
detail::tmat2x3<T, P> m(detail::tmat2x3<T, P>::_null);
tmat2x3<T, P> m(tmat2x3<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
@ -95,11 +95,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec2, detail::tvec3, T, P>
struct compute_outerProduct<tvec2, tvec3, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec3>::type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec3>::type call(tvec2<T, P> const & c, tvec3<T, P> const & r)
{
detail::tmat3x2<T, P> m(detail::tmat3x2<T, P>::_null);
tmat3x2<T, P> m(tmat3x2<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[1][0] = c.x * r.y;
@ -111,11 +111,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec4, detail::tvec2, T, P>
struct compute_outerProduct<tvec4, tvec2, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec2>::type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec2>::type call(tvec4<T, P> const & c, tvec2<T, P> const & r)
{
detail::tmat2x4<T, P> m(detail::tmat2x4<T, P>::_null);
tmat2x4<T, P> m(tmat2x4<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
@ -129,11 +129,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec2, detail::tvec4, T, P>
struct compute_outerProduct<tvec2, tvec4, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec4>::type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec4>::type call(tvec2<T, P> const & c, tvec4<T, P> const & r)
{
detail::tmat4x2<T, P> m(detail::tmat4x2<T, P>::_null);
tmat4x2<T, P> m(tmat4x2<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[1][0] = c.x * r.y;
@ -147,11 +147,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec4, detail::tvec3, T, P>
struct compute_outerProduct<tvec4, tvec3, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec3>::type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec3>::type call(tvec4<T, P> const & c, tvec3<T, P> const & r)
{
detail::tmat3x4<T, P> m(detail::tmat3x4<T, P>::_null);
tmat3x4<T, P> m(tmat3x4<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
@ -169,11 +169,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_outerProduct<detail::tvec3, detail::tvec4, T, P>
struct compute_outerProduct<tvec3, tvec4, T, P>
{
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec4>::type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec4>::type call(tvec3<T, P> const & c, tvec4<T, P> const & r)
{
detail::tmat4x3<T, P> m(detail::tmat4x3<T, P>::_null);
tmat4x3<T, P> m(tmat4x3<T, P>::_null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
@ -194,11 +194,11 @@ namespace detail
struct compute_transpose{};
template <typename T, precision P>
struct compute_transpose<detail::tmat2x2, T, P>
struct compute_transpose<tmat2x2, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
{
detail::tmat2x2<T, P> result(detail::tmat2x2<T, P>::_null);
tmat2x2<T, P> result(tmat2x2<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
@ -208,11 +208,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat2x3, T, P>
struct compute_transpose<tmat2x3, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
{
detail::tmat3x2<T, P> result(detail::tmat3x2<T, P>::_null);
tmat3x2<T, P> result(tmat3x2<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
@ -224,11 +224,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat2x4, T, P>
struct compute_transpose<tmat2x4, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
{
detail::tmat4x2<T, P> result(detail::tmat4x2<T, P>::_null);
tmat4x2<T, P> result(tmat4x2<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
@ -242,11 +242,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat3x2, T, P>
struct compute_transpose<tmat3x2, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
{
detail::tmat2x3<T, P> result(detail::tmat2x3<T, P>::_null);
tmat2x3<T, P> result(tmat2x3<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -258,11 +258,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat3x3, T, P>
struct compute_transpose<tmat3x3, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
{
detail::tmat3x3<T, P> result(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> result(tmat3x3<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -279,11 +279,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat3x4, T, P>
struct compute_transpose<tmat3x4, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
{
detail::tmat4x3<T, P> result(detail::tmat4x3<T, P>::_null);
tmat4x3<T, P> result(tmat4x3<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -301,11 +301,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat4x2, T, P>
struct compute_transpose<tmat4x2, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
{
detail::tmat2x4<T, P> result(detail::tmat2x4<T, P>::_null);
tmat2x4<T, P> result(tmat2x4<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -319,11 +319,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat4x3, T, P>
struct compute_transpose<tmat4x3, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
{
detail::tmat3x4<T, P> result(detail::tmat3x4<T, P>::_null);
tmat3x4<T, P> result(tmat3x4<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -341,11 +341,11 @@ namespace detail
};
template <typename T, precision P>
struct compute_transpose<detail::tmat4x4, T, P>
struct compute_transpose<tmat4x4, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
{
detail::tmat4x4<T, P> result(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> result(tmat4x4<T, P>::_null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
@ -373,18 +373,18 @@ namespace detail
struct compute_determinant{};
template <typename T, precision P>
struct compute_determinant<detail::tmat2x2, T, P>
struct compute_determinant<tmat2x2, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tmat2x2<T, P> const & m)
GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
{
return m[0][0] * m[1][1] - m[1][0] * m[0][1];
}
};
template <typename T, precision P>
struct compute_determinant<detail::tmat3x3, T, P>
struct compute_determinant<tmat3x3, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tmat3x3<T, P> const & m)
GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
{
return
+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
@ -394,9 +394,9 @@ namespace detail
};
template <typename T, precision P>
struct compute_determinant<detail::tmat4x4, T, P>
struct compute_determinant<tmat4x4, T, P>
{
GLM_FUNC_QUALIFIER static T call(detail::tmat4x4<T, P> const & m)
GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
{
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
@ -405,7 +405,7 @@ namespace detail
T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
detail::tvec4<T, P> DetCof(
tvec4<T, P> DetCof(
+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@ -454,7 +454,7 @@ namespace detail
GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inverse' only accept floating-point inputs");
return detail::compute_inverse<matType, T, P>::call(m);
return detail::compute_inverse(m);
}
}//namespace glm

6
glm/detail/func_noise.hpp
View file

@ -63,7 +63,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
/// Returns a 3D noise value based on the input value x.
///
@ -72,7 +72,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
/// Returns a 4D noise value based on the input value x.
///
@ -81,7 +81,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
/// @}
}//namespace glm

288
glm/detail/func_noise.inl
View file

@ -33,43 +33,43 @@ namespace glm{
namespace detail
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> grad4(T const & j, detail::tvec4<T, P> const & ip)
GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
{
detail::tvec3<T, P> pXYZ = floor(fract(detail::tvec3<T, P>(j) * detail::tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
T pW = static_cast<T>(1.5) - dot(abs(pXYZ), detail::tvec3<T, P>(1));
detail::tvec4<T, P> s = detail::tvec4<T, P>(lessThan(detail::tvec4<T, P>(pXYZ, pW), detail::tvec4<T, P>(0.0)));
pXYZ = pXYZ + (detail::tvec3<T, P>(s) * T(2) - T(1)) * s.w;
return detail::tvec4<T, P>(pXYZ, pW);
tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w;
return tvec4<T, P>(pXYZ, pW);
}
}//namespace detail
template <typename T>
GLM_FUNC_QUALIFIER T noise1(T const & x)
{
return noise1(detail::tvec2<T, defaultp>(x, T(0)));
return noise1(tvec2<T, defaultp>(x, T(0)));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> noise2(T const & x)
GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
{
return detail::tvec2<T, defaultp>(
return tvec2<T, defaultp>(
noise1(x + T(0.0)),
noise1(x + T(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> noise3(T const & x)
GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
{
return detail::tvec3<T, defaultp>(
return tvec3<T, defaultp>(
noise1(x - T(1.0)),
noise1(x + T(0.0)),
noise1(x + T(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> noise4(T const & x)
GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
{
return detail::tvec4<T, defaultp>(
return tvec4<T, defaultp>(
noise1(x - T(1.0)),
noise1(x + T(0.0)),
noise1(x + T(1.0)),
@ -77,38 +77,38 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T noise1(detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
{
detail::tvec4<T, P> const C = detail::tvec4<T, P>(
tvec4<T, P> const C = tvec4<T, P>(
T( 0.211324865405187), // (3.0 - sqrt(3.0)) / 6.0
T( 0.366025403784439), // 0.5 * (sqrt(3.0) - 1.0)
T(-0.577350269189626), // -1.0 + 2.0 * C.x
T( 0.024390243902439)); // 1.0 / 41.0
// First corner
detail::tvec2<T, P> i = floor(v + dot(v, detail::tvec2<T, P>(C[1])));
detail::tvec2<T, P> x0 = v - i + dot(i, detail::tvec2<T, P>(C[0]));
tvec2<T, P> i = floor(v + dot(v, tvec2<T, P>(C[1])));
tvec2<T, P> x0 = v - i + dot(i, tvec2<T, P>(C[0]));
// Other corners
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
detail::tvec2<T, P> i1 = (x0.x > x0.y) ? detail::tvec2<T, P>(1, 0) : detail::tvec2<T, P>(0, 1);
tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
detail::tvec4<T, P> x12 = detail::tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T, P>(C.x, C.x, C.z, C.z);
x12 = detail::tvec4<T, P>(detail::tvec2<T, P>(x12) - i1, x12.z, x12.w);
tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
// Permutations
i = mod(i, T(289)); // Avoid truncation effects in permutation
detail::tvec3<T, P> p = detail::permute(
detail::permute(i.y + detail::tvec3<T, P>(T(0), i1.y, T(1))) + i.x + detail::tvec3<T, P>(T(0), i1.x, T(1)));
tvec3<T, P> p = detail::permute(
detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
detail::tvec3<T, P> m = max(T(0.5) - detail::tvec3<T, P>(
tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
dot(x0, x0),
dot(detail::tvec2<T, P>(x12.x, x12.y), detail::tvec2<T, P>(x12.x, x12.y)),
dot(detail::tvec2<T, P>(x12.z, x12.w), detail::tvec2<T, P>(x12.z, x12.w))), T(0));
dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
m = m * m;
m = m * m;
@ -116,17 +116,17 @@ namespace detail
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
detail::tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
detail::tvec3<T, P> h = abs(x) - T(0.5);
detail::tvec3<T, P> ox = floor(x + T(0.5));
detail::tvec3<T, P> a0 = x - ox;
tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
tvec3<T, P> h = abs(x) - T(0.5);
tvec3<T, P> ox = floor(x + T(0.5));
tvec3<T, P> a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
// Compute final noise value at P
detail::tvec3<T, P> g;
tvec3<T, P> g;
g.x = a0.x * x0.x + h.x * x0.y;
//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
g.y = a0.y * x12.x + h.y * x12.y;
@ -135,84 +135,84 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T, P> const & v)
GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
{
detail::tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
detail::tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
// First corner
detail::tvec3<T, P> i(floor(v + dot(v, detail::tvec3<T, P>(C.y))));
detail::tvec3<T, P> x0(v - i + dot(i, detail::tvec3<T, P>(C.x)));
tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
// Other corners
detail::tvec3<T, P> g(step(detail::tvec3<T, P>(x0.y, x0.z, x0.x), x0));
detail::tvec3<T, P> l(T(1) - g);
detail::tvec3<T, P> i1(min(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
detail::tvec3<T, P> i2(max(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
tvec3<T, P> l(T(1) - g);
tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
detail::tvec3<T, P> x1(x0 - i1 + C.x);
detail::tvec3<T, P> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
detail::tvec3<T, P> x3(x0 - D.y); // -1.0+3.0*C.x = -0.5 = -D.y
tvec3<T, P> x1(x0 - i1 + C.x);
tvec3<T, P> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
tvec3<T, P> x3(x0 - D.y); // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
detail::tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
i.z + detail::tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
i.y + detail::tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
i.x + detail::tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
detail::tvec3<T, P> ns(n_ * detail::tvec3<T, P>(D.w, D.y, D.z) - detail::tvec3<T, P>(D.x, D.z, D.x));
tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
detail::tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z)); // mod(p,7*7)
tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z)); // mod(p,7*7)
detail::tvec4<T, P> x_(floor(j * ns.z));
detail::tvec4<T, P> y_(floor(j - T(7) * x_)); // mod(j,N)
tvec4<T, P> x_(floor(j * ns.z));
tvec4<T, P> y_(floor(j - T(7) * x_)); // mod(j,N)
detail::tvec4<T, P> x(x_ * ns.x + ns.y);
detail::tvec4<T, P> y(y_ * ns.x + ns.y);
detail::tvec4<T, P> h(T(1) - abs(x) - abs(y));
tvec4<T, P> x(x_ * ns.x + ns.y);
tvec4<T, P> y(y_ * ns.x + ns.y);
tvec4<T, P> h(T(1) - abs(x) - abs(y));
detail::tvec4<T, P> b0(x.x, x.y, y.x, y.y);
detail::tvec4<T, P> b1(x.z, x.w, y.z, y.w);
tvec4<T, P> b0(x.x, x.y, y.x, y.y);
tvec4<T, P> b1(x.z, x.w, y.z, y.w);
// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
detail::tvec4<T, P> s0(floor(b0) * T(2) + T(1));
detail::tvec4<T, P> s1(floor(b1) * T(2) + T(1));
detail::tvec4<T, P> sh(-step(h, detail::tvec4<T, P>(0.0)));
tvec4<T, P> s0(floor(b0) * T(2) + T(1));
tvec4<T, P> s1(floor(b1) * T(2) + T(1));
tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
detail::tvec4<T, P> a0 = detail::tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
detail::tvec4<T, P> a1 = detail::tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
tvec4<T, P> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
detail::tvec3<T, P> p0(a0.x, a0.y, h.x);
detail::tvec3<T, P> p1(a0.z, a0.w, h.y);
detail::tvec3<T, P> p2(a1.x, a1.y, h.z);
detail::tvec3<T, P> p3(a1.z, a1.w, h.w);
tvec3<T, P> p0(a0.x, a0.y, h.x);
tvec3<T, P> p1(a0.z, a0.w, h.y);
tvec3<T, P> p2(a1.x, a1.y, h.z);
tvec3<T, P> p3(a1.z, a1.w, h.w);
// Normalise gradients
detail::tvec4<T, P> norm = taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
tvec4<T, P> norm = taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
detail::tvec4<T, P> m = max(T(0.6) - detail::tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
m = m * m;
return T(42) * dot(m * m, detail::tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T, P> const & v)
GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
{
detail::tvec4<T, P> const C(
tvec4<T, P> const C(
0.138196601125011, // (5 - sqrt(5))/20 G4
0.276393202250021, // 2 * G4
0.414589803375032, // 3 * G4
@ -222,66 +222,66 @@ namespace detail
T const F4 = static_cast<T>(0.309016994374947451);
// First corner
detail::tvec4<T, P> i = floor(v + dot(v, detail::tvec4<T, P>(F4)));
detail::tvec4<T, P> x0 = v - i + dot(i, detail::tvec4<T, P>(C.x));
tvec4<T, P> i = floor(v + dot(v, tvec4<T, P>(F4)));
tvec4<T, P> x0 = v - i + dot(i, tvec4<T, P>(C.x));
// Other corners
// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
detail::tvec4<T, P> i0;
detail::tvec3<T, P> isX = step(detail::tvec3<T, P>(x0.y, x0.z, x0.w), detail::tvec3<T, P>(x0.x));
detail::tvec3<T, P> isYZ = step(detail::tvec3<T, P>(x0.z, x0.w, x0.w), detail::tvec3<T, P>(x0.y, x0.y, x0.z));
tvec4<T, P> i0;
tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
// i0.x = dot(isX, vec3(1.0));
//i0.x = isX.x + isX.y + isX.z;
//i0.yzw = static_cast<T>(1) - isX;
i0 = detail::tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
// i0.y += dot(isYZ.xy, vec2(1.0));
i0.y += isYZ.x + isYZ.y;
//i0.zw += 1.0 - detail::tvec2<T, P>(isYZ.x, isYZ.y);
//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
i0.z += static_cast<T>(1) - isYZ.x;
i0.w += static_cast<T>(1) - isYZ.y;
i0.z += isYZ.z;
i0.w += static_cast<T>(1) - isYZ.z;
// i0 now contains the unique values 0,1,2,3 in each channel
detail::tvec4<T, P> i3 = clamp(i0, T(0), T(1));
detail::tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
detail::tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
tvec4<T, P> i3 = clamp(i0, T(0), T(1));
tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
// x0 = x0 - 0.0 + 0.0 * C.xxxx
// x1 = x0 - i1 + 0.0 * C.xxxx
// x2 = x0 - i2 + 0.0 * C.xxxx
// x3 = x0 - i3 + 0.0 * C.xxxx
// x4 = x0 - 1.0 + 4.0 * C.xxxx
detail::tvec4<T, P> x1 = x0 - i1 + C.x;
detail::tvec4<T, P> x2 = x0 - i2 + C.y;
detail::tvec4<T, P> x3 = x0 - i3 + C.z;
detail::tvec4<T, P> x4 = x0 + C.w;
tvec4<T, P> x1 = x0 - i1 + C.x;
tvec4<T, P> x2 = x0 - i2 + C.y;
tvec4<T, P> x3 = x0 - i3 + C.z;
tvec4<T, P> x4 = x0 + C.w;
// Permutations
i = mod(i, T(289));
T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
detail::tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
i.w + detail::tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
i.z + detail::tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
i.y + detail::tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
i.x + detail::tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
detail::tvec4<T, P> ip = detail::tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
detail::tvec4<T, P> p0 = detail::grad4(j0, ip);
detail::tvec4<T, P> p1 = detail::grad4(j1.x, ip);
detail::tvec4<T, P> p2 = detail::grad4(j1.y, ip);
detail::tvec4<T, P> p3 = detail::grad4(j1.z, ip);
detail::tvec4<T, P> p4 = detail::grad4(j1.w, ip);
tvec4<T, P> p0 = detail::grad4(j0, ip);
tvec4<T, P> p1 = detail::grad4(j1.x, ip);
tvec4<T, P> p2 = detail::grad4(j1.y, ip);
tvec4<T, P> p3 = detail::grad4(j1.z, ip);
tvec4<T, P> p4 = detail::grad4(j1.w, ip);
// Normalise gradients
detail::tvec4<T, P> norm = detail::taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
@ -289,96 +289,96 @@ namespace detail
p4 *= taylorInvSqrt(dot(p4, p4));
// Mix contributions from the five corners
detail::tvec3<T, P> m0 = max(T(0.6) - detail::tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
detail::tvec2<T, P> m1 = max(T(0.6) - detail::tvec2<T, P>(dot(x3, x3), dot(x4, x4) ), T(0));
tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4) ), T(0));
m0 = m0 * m0;
m1 = m1 * m1;
return T(49) * (
dot(m0 * m0, detail::tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
dot(m1 * m1, detail::tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
{
return detail::tvec2<T, P>(
noise1(x + detail::tvec2<T, P>(0.0)),
noise1(detail::tvec2<T, P>(0.0) - x));
return tvec2<T, P>(
noise1(x + tvec2<T, P>(0.0)),
noise1(tvec2<T, P>(0.0) - x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
{
return detail::tvec2<T, P>(
noise1(x + detail::tvec3<T, P>(0.0)),
noise1(detail::tvec3<T, P>(0.0) - x));
return tvec2<T, P>(
noise1(x + tvec3<T, P>(0.0)),
noise1(tvec3<T, P>(0.0) - x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
{
return detail::tvec2<T, P>(
noise1(x + detail::tvec4<T, P>(0)),
noise1(detail::tvec4<T, P>(0) - x));
return tvec2<T, P>(
noise1(x + tvec4<T, P>(0)),
noise1(tvec4<T, P>(0) - x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
{
return detail::tvec3<T, P>(
noise1(x - detail::tvec2<T, P>(1.0)),
noise1(x + detail::tvec2<T, P>(0.0)),
noise1(x + detail::tvec2<T, P>(1.0)));
return tvec3<T, P>(
noise1(x - tvec2<T, P>(1.0)),
noise1(x + tvec2<T, P>(0.0)),
noise1(x + tvec2<T, P>(1.0)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
{
return detail::tvec3<T, P>(
noise1(x - detail::tvec3<T, P>(1.0)),
noise1(x + detail::tvec3<T, P>(0.0)),
noise1(x + detail::tvec3<T, P>(1.0)));
return tvec3<T, P>(
noise1(x - tvec3<T, P>(1.0)),
noise1(x + tvec3<T, P>(0.0)),
noise1(x + tvec3<T, P>(1.0)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
{
return detail::tvec3<T, P>(
noise1(x - detail::tvec4<T, P>(1)),
noise1(x + detail::tvec4<T, P>(0)),
noise1(x + detail::tvec4<T, P>(1)));
return tvec3<T, P>(
noise1(x - tvec4<T, P>(1)),
noise1(x + tvec4<T, P>(0)),
noise1(x + tvec4<T, P>(1)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
{
return detail::tvec4<T, P>(
noise1(x - detail::tvec2<T, P>(1)),
noise1(x + detail::tvec2<T, P>(0)),
noise1(x + detail::tvec2<T, P>(1)),
noise1(x + detail::tvec2<T, P>(2)));
return tvec4<T, P>(
noise1(x - tvec2<T, P>(1)),
noise1(x + tvec2<T, P>(0)),
noise1(x + tvec2<T, P>(1)),
noise1(x + tvec2<T, P>(2)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
{
return detail::tvec4<T, P>(
noise1(x - detail::tvec3<T, P>(1)),
noise1(x + detail::tvec3<T, P>(0)),
noise1(x + detail::tvec3<T, P>(1)),
noise1(x + detail::tvec3<T, P>(2)));
return tvec4<T, P>(
noise1(x - tvec3<T, P>(1)),
noise1(x + tvec3<T, P>(0)),
noise1(x + tvec3<T, P>(1)),
noise1(x + tvec3<T, P>(2)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
{
return detail::tvec4<T, P>(
noise1(x - detail::tvec4<T, P>(1)),
noise1(x + detail::tvec4<T, P>(0)),
noise1(x + detail::tvec4<T, P>(1)),
noise1(x + detail::tvec4<T, P>(2)));
return tvec4<T, P>(
noise1(x - tvec4<T, P>(1)),
noise1(x + tvec4<T, P>(0)),
noise1(x + tvec4<T, P>(1)),
noise1(x + tvec4<T, P>(2)));
}
}//namespace glm

8
glm/detail/intrinsic_matrix.inl
View file

@ -448,7 +448,7 @@ GLM_FUNC_QUALIFIER __m128 sse_detd_ps
__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
//detail::tvec4<T, P> DetCof(
//tvec4<T, P> DetCof(
// + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
// - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
// + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@ -514,7 +514,7 @@ GLM_FUNC_QUALIFIER __m128 sse_det_ps
__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
//detail::tvec4<T, P> DetCof(
//tvec4<T, P> DetCof(
// + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
// - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
// + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@ -1003,7 +1003,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
__m128 Sin0 = _mm_set_ss(s);
__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
// detail::tvec3<T, P> temp = (valType(1) - c) * axis;
// tvec3<T, P> temp = (valType(1) - c) * axis;
__m128 Temp0 = _mm_sub_ps(one, CosA);
__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
@ -1049,7 +1049,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
Result[2] = TmpC4;
Result[3] = _mm_set_ps(1, 0, 0, 0);
//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::_null);
//tmat4x4<valType> Result(tmat4x4<valType>::_null);
//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];

174
glm/detail/intrinsic_vector_relational.inl
View file

@ -28,10 +28,10 @@
//
//// lessThan
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type lessThan
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -39,14 +39,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
// return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThan
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -54,14 +54,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
// return typename tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type lessThan
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -69,15 +69,15 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
// return typename tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
//}
//
//// lessThanEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type lessThanEqual
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThanEqual
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -85,14 +85,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
// return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThanEqual
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -100,14 +100,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
// return typename tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type lessThanEqual
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -115,15 +115,15 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
// return typename tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
//}
//
//// greaterThan
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type greaterThan
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThan
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -131,14 +131,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
// return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThan
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -146,14 +146,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
// return typename tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type greaterThan
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -161,15 +161,15 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
// return typename tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
//}
//
//// greaterThanEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type greaterThanEqual
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThanEqual
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -177,14 +177,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
// return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThanEqual
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -192,14 +192,14 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
// return typename tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type greaterThanEqual
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -207,15 +207,15 @@
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
// return typename tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
//}
//
//// equal
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type equal
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type equal
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -224,14 +224,14 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
// return typename tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type equal
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -240,14 +240,14 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
// return typename tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type equal
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -256,15 +256,15 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
// return typename tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
//}
//
//// notEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type notEqual
//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type notEqual
//(
// detail::tvec2<T, P> const & x,
// detail::tvec2<T, P> const & y
// tvec2<T, P> const & x,
// tvec2<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -273,14 +273,14 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
// return typename tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type notEqual
//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
//(
// detail::tvec3<T, P> const & x,
// detail::tvec3<T, P> const & y
// tvec3<T, P> const & x,
// tvec3<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -289,14 +289,14 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
// return typename tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type notEqual
//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
//(
// detail::tvec4<T, P> const & x,
// detail::tvec4<T, P> const & y
// tvec4<T, P> const & x,
// tvec4<T, P> const & y
//)
//{
// GLM_STATIC_ASSERT(
@ -305,62 +305,62 @@
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
// return typename tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
//}
//
//// any
//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
//{
// return x.x || x.y;
//}
//
//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
//{
// return x.x || x.y || x.z;
//}
//
//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
//GLM_FUNC_QUALIFIER bool any(tvec4<bool> const & x)
//{
// return x.x || x.y || x.z || x.w;
//}
//
//// all
//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
//{
// return x.x && x.y;
//}
//
//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
//{
// return x.x && x.y && x.z;
//}
//
//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
//{
// return x.x && x.y && x.z && x.w;
//}
//
//// not
//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
//(
// detail::tvec2<bool> const & v
// tvec2<bool> const & v
//)
//{
// return detail::tvec2<bool>::bool_type(!v.x, !v.y);
// return tvec2<bool>::bool_type(!v.x, !v.y);
//}
//
//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
//(
// detail::tvec3<bool> const & v
// tvec3<bool> const & v
//)
//{
// return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
// return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
//}
//
//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
//(
// detail::tvec4<bool> const & v
// tvec4<bool> const & v
//)
//{
// return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
// return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
//}

14
glm/detail/setup.hpp
View file

@ -22,7 +22,7 @@
///
/// @ref core
/// @file glm/core/setup.hpp
/// @date 2006-11-13 / 2013-03-30
/// @date 2006-11-13 / 2014-10-05
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
@ -548,6 +548,18 @@
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC10))) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)))
#define GLM_HAS_TEMPLATE_ALIASES ( \
(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12))) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
__has_feature(cxx_alias_templates))
#define GLM_HAS_RANGE_FOR ( \
(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
__has_feature(cxx_range_for))
// OpenMP
#ifdef _OPENMP
# if(GLM_COMPILER & GLM_COMPILER_GCC)

155
glm/detail/type_mat.hpp
View file

@ -33,6 +33,10 @@
namespace glm{
namespace detail
{
template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
struct outerProduct_trait{};
}//namespace detail
template <typename T, precision P> struct tvec2;
template <typename T, precision P> struct tvec3;
template <typename T, precision P> struct tvec4;
@ -46,13 +50,6 @@ namespace detail
template <typename T, precision P> struct tmat4x3;
template <typename T, precision P> struct tmat4x4;
template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
struct outerProduct_trait{};
template <template <class, precision> class matType, typename T, precision P>
struct compute_inverse{};
}//namespace detail
/// @addtogroup core_precision
/// @{
@ -61,42 +58,42 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, lowp> lowp_mat2;
typedef tmat2x2<float, lowp> lowp_mat2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, mediump> mediump_mat2;
typedef tmat2x2<float, mediump> mediump_mat2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, highp> highp_mat2;
typedef tmat2x2<float, highp> highp_mat2;
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, lowp> lowp_mat2x2;
typedef tmat2x2<float, lowp> lowp_mat2x2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, mediump> mediump_mat2x2;
typedef tmat2x2<float, mediump> mediump_mat2x2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<float, highp> highp_mat2x2;
typedef tmat2x2<float, highp> highp_mat2x2;
/// @}
@ -108,21 +105,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<float, lowp> lowp_mat2x3;
typedef tmat2x3<float, lowp> lowp_mat2x3;
/// 2 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<float, mediump> mediump_mat2x3;
typedef tmat2x3<float, mediump> mediump_mat2x3;
/// 2 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<float, highp> highp_mat2x3;
typedef tmat2x3<float, highp> highp_mat2x3;
/// @}
@ -134,21 +131,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<float, lowp> lowp_mat2x4;
typedef tmat2x4<float, lowp> lowp_mat2x4;
/// 2 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<float, mediump> mediump_mat2x4;
typedef tmat2x4<float, mediump> mediump_mat2x4;
/// 2 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<float, highp> highp_mat2x4;
typedef tmat2x4<float, highp> highp_mat2x4;
/// @}
@ -160,21 +157,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<float, lowp> lowp_mat3x2;
typedef tmat3x2<float, lowp> lowp_mat3x2;
/// 3 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<float, mediump> mediump_mat3x2;
typedef tmat3x2<float, mediump> mediump_mat3x2;
/// 3 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<float, highp> highp_mat3x2;
typedef tmat3x2<float, highp> highp_mat3x2;
/// @}
@ -186,42 +183,42 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, lowp> lowp_mat3;
typedef tmat3x3<float, lowp> lowp_mat3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, mediump> mediump_mat3;
typedef tmat3x3<float, mediump> mediump_mat3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, highp> highp_mat3;
typedef tmat3x3<float, highp> highp_mat3;
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, lowp> lowp_mat3x3;
typedef tmat3x3<float, lowp> lowp_mat3x3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, mediump> mediump_mat3x3;
typedef tmat3x3<float, mediump> mediump_mat3x3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, highp> highp_mat3x3;
typedef tmat3x3<float, highp> highp_mat3x3;
/// @}
@ -233,21 +230,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<float, lowp> lowp_mat3x4;
typedef tmat3x4<float, lowp> lowp_mat3x4;
/// 3 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<float, mediump> mediump_mat3x4;
typedef tmat3x4<float, mediump> mediump_mat3x4;
/// 3 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<float, highp> highp_mat3x4;
typedef tmat3x4<float, highp> highp_mat3x4;
/// @}
@ -259,21 +256,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<float, lowp> lowp_mat4x2;
typedef tmat4x2<float, lowp> lowp_mat4x2;
/// 4 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<float, mediump> mediump_mat4x2;
typedef tmat4x2<float, mediump> mediump_mat4x2;
/// 4 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<float, highp> highp_mat4x2;
typedef tmat4x2<float, highp> highp_mat4x2;
/// @}
@ -285,21 +282,21 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<float, lowp> lowp_mat4x3;
typedef tmat4x3<float, lowp> lowp_mat4x3;
/// 4 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<float, mediump> mediump_mat4x3;
typedef tmat4x3<float, mediump> mediump_mat4x3;
/// 4 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<float, highp> highp_mat4x3;
typedef tmat4x3<float, highp> highp_mat4x3;
/// @}
@ -312,42 +309,42 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, lowp> lowp_mat4;
typedef tmat4x4<float, lowp> lowp_mat4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, mediump> mediump_mat4;
typedef tmat4x4<float, mediump> mediump_mat4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, highp> highp_mat4;
typedef tmat4x4<float, highp> highp_mat4;
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, lowp> lowp_mat4x4;
typedef tmat4x4<float, lowp> lowp_mat4x4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, mediump> mediump_mat4x4;
typedef tmat4x4<float, mediump> mediump_mat4x4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<float, highp> highp_mat4x4;
typedef tmat4x4<float, highp> highp_mat4x4;
/// @}
@ -450,37 +447,37 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, lowp> lowp_dmat2;
typedef tmat2x2<double, lowp> lowp_dmat2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, mediump> mediump_dmat2;
typedef tmat2x2<double, mediump> mediump_dmat2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, highp> highp_dmat2;
typedef tmat2x2<double, highp> highp_dmat2;
/// 2 columns of 2 components matrix of low precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, lowp> lowp_dmat2x2;
typedef tmat2x2<double, lowp> lowp_dmat2x2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, mediump> mediump_dmat2x2;
typedef tmat2x2<double, mediump> mediump_dmat2x2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<double, highp> highp_dmat2x2;
typedef tmat2x2<double, highp> highp_dmat2x2;
/// @}
@ -491,19 +488,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<double, lowp> lowp_dmat2x3;
typedef tmat2x3<double, lowp> lowp_dmat2x3;
/// 2 columns of 3 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<double, mediump> mediump_dmat2x3;
typedef tmat2x3<double, mediump> mediump_dmat2x3;
/// 2 columns of 3 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<double, highp> highp_dmat2x3;
typedef tmat2x3<double, highp> highp_dmat2x3;
/// @}
@ -514,19 +511,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<double, lowp> lowp_dmat2x4;
typedef tmat2x4<double, lowp> lowp_dmat2x4;
/// 2 columns of 4 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<double, mediump> mediump_dmat2x4;
typedef tmat2x4<double, mediump> mediump_dmat2x4;
/// 2 columns of 4 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<double, highp> highp_dmat2x4;
typedef tmat2x4<double, highp> highp_dmat2x4;
/// @}
@ -537,19 +534,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<double, lowp> lowp_dmat3x2;
typedef tmat3x2<double, lowp> lowp_dmat3x2;
/// 3 columns of 2 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<double, mediump> mediump_dmat3x2;
typedef tmat3x2<double, mediump> mediump_dmat3x2;
/// 3 columns of 2 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<double, highp> highp_dmat3x2;
typedef tmat3x2<double, highp> highp_dmat3x2;
/// @}
@ -560,37 +557,37 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<float, lowp> lowp_dmat3;
typedef tmat3x3<float, lowp> lowp_dmat3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<double, mediump> mediump_dmat3;
typedef tmat3x3<double, mediump> mediump_dmat3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<double, highp> highp_dmat3;
typedef tmat3x3<double, highp> highp_dmat3;
/// 3 columns of 3 components matrix of low precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<double, lowp> lowp_dmat3x3;
typedef tmat3x3<double, lowp> lowp_dmat3x3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<double, mediump> mediump_dmat3x3;
typedef tmat3x3<double, mediump> mediump_dmat3x3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<double, highp> highp_dmat3x3;
typedef tmat3x3<double, highp> highp_dmat3x3;
/// @}
@ -601,19 +598,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<double, lowp> lowp_dmat3x4;
typedef tmat3x4<double, lowp> lowp_dmat3x4;
/// 3 columns of 4 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<double, mediump> mediump_dmat3x4;
typedef tmat3x4<double, mediump> mediump_dmat3x4;
/// 3 columns of 4 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<double, highp> highp_dmat3x4;
typedef tmat3x4<double, highp> highp_dmat3x4;
/// @}
@ -624,19 +621,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<double, lowp> lowp_dmat4x2;
typedef tmat4x2<double, lowp> lowp_dmat4x2;
/// 4 columns of 2 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<double, mediump> mediump_dmat4x2;
typedef tmat4x2<double, mediump> mediump_dmat4x2;
/// 4 columns of 2 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<double, highp> highp_dmat4x2;
typedef tmat4x2<double, highp> highp_dmat4x2;
/// @}
@ -647,19 +644,19 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<double, lowp> lowp_dmat4x3;
typedef tmat4x3<double, lowp> lowp_dmat4x3;
/// 4 columns of 3 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<double, mediump> mediump_dmat4x3;
typedef tmat4x3<double, mediump> mediump_dmat4x3;
/// 4 columns of 3 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<double, highp> highp_dmat4x3;
typedef tmat4x3<double, highp> highp_dmat4x3;
/// @}
@ -670,37 +667,37 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, lowp> lowp_dmat4;
typedef tmat4x4<double, lowp> lowp_dmat4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, mediump> mediump_dmat4;
typedef tmat4x4<double, mediump> mediump_dmat4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, highp> highp_dmat4;
typedef tmat4x4<double, highp> highp_dmat4;
/// 4 columns of 4 components matrix of low precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, lowp> lowp_dmat4x4;
typedef tmat4x4<double, lowp> lowp_dmat4x4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, mediump> mediump_dmat4x4;
typedef tmat4x4<double, mediump> mediump_dmat4x4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<double, highp> highp_dmat4x4;
typedef tmat4x4<double, highp> highp_dmat4x4;
/// @}

4
glm/detail/type_mat2x2.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat2x2
@ -242,7 +241,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> const operator-(
tmat2x2<T, P> const & m);
} //namespace detail
} //namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

48
glm/detail/type_mat2x2.inl
View file

@ -29,6 +29,23 @@
namespace glm{
namespace detail
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat2x2<T, P> compute_inverse(tmat2x2<T, P> const & m)
{
T OneOverDeterminant = static_cast<T>(1) / (
+ m[0][0] * m[1][1]
- m[1][0] * m[0][1]);
tmat2x2<T, P> Inverse(
+ m[1][1] * OneOverDeterminant,
- m[0][1] * OneOverDeterminant,
- m[1][0] * OneOverDeterminant,
+ m[0][0] * OneOverDeterminant);
return Inverse;
}
}//namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x2<T, P>::length() const {return 2;}
@ -324,7 +341,7 @@ namespace detail
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= (tmat2x2<U, P> const & m)
{
return (*this = *this * detail::compute_inverse<detail::tmat2x2, T, P>::call(m));
return (*this = *this * detail::compute_inverse<T, P>(m));
}
template <typename T, precision P>
@ -359,25 +376,6 @@ namespace detail
return Result;
}
template <typename T, precision P>
struct compute_inverse<detail::tmat2x2, T, P>
{
GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
{
T OneOverDeterminant = static_cast<T>(1) / (
+ m[0][0] * m[1][1]
- m[1][0] * m[0][1]);
detail::tmat2x2<T, P> Inverse(
+ m[1][1] * OneOverDeterminant,
- m[0][1] * OneOverDeterminant,
- m[1][0] * OneOverDeterminant,
+ m[0][0] * OneOverDeterminant);
return Inverse;
}
};
//////////////////////////////////////////////////////////////
// Binary operators
@ -484,7 +482,7 @@ namespace detail
typename tmat2x2<T, P>::row_type const & v
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
m[0][0] * v.x + m[1][0] * v.y,
m[0][1] * v.x + m[1][1] * v.y);
}
@ -496,7 +494,7 @@ namespace detail
tmat2x2<T, P> const & m
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
v.x * m[0][0] + v.y * m[0][1],
v.x * m[1][0] + v.y * m[1][1]);
}
@ -580,7 +578,7 @@ namespace detail
typename tmat2x2<T, P>::row_type & v
)
{
return detail::compute_inverse<detail::tmat2x2, T, P>::call(m) * v;
return detail::compute_inverse<tmat2x2, T, P>::call(m) * v;
}
template <typename T, precision P>
@ -590,7 +588,7 @@ namespace detail
tmat2x2<T, P> const & m
)
{
return v * detail::compute_inverse<detail::tmat2x2, T, P>::call(m);
return v * detail::compute_inverse<tmat2x2, T, P>::call(m);
}
template <typename T, precision P>
@ -638,6 +636,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat2x3.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat2x3
@ -205,8 +204,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> const operator- (
tmat2x3<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

4
glm/detail/type_mat2x3.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x3<T, P>::length() const
@ -584,5 +583,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat2x4.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat2x4
@ -207,8 +206,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> const operator- (
tmat2x4<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

16
glm/detail/type_mat2x4.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x4<T, P>::length() const
@ -179,8 +178,8 @@ namespace detail
tmat2x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
}
template <typename T, precision P>
@ -219,8 +218,8 @@ namespace detail
tmat3x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
}
template <typename T, precision P>
@ -239,8 +238,8 @@ namespace detail
tmat4x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(T(0)));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(T(0)));
this->value[0] = col_type(m[0], tvec2<T, P>(T(0)));
this->value[1] = col_type(m[1], tvec2<T, P>(T(0)));
}
template <typename T, precision P>
@ -603,5 +602,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat3x2.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat3x2
@ -210,8 +209,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> const operator-(
tmat3x2<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

5
glm/detail/type_mat3x2.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x2<T, P>::length() const
@ -616,6 +615,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat3x3.hpp
View file

@ -40,8 +40,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat3x3
@ -244,8 +243,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> const operator-(
tmat3x3<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

62
glm/detail/type_mat3x3.inl
View file

@ -29,6 +29,29 @@
namespace glm{
namespace detail
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat3x3<T, P> compute_inverse(tmat3x3<T, P> const & m)
{
T OneOverDeterminant = static_cast<T>(1) / (
+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
tmat3x3<T, P> Inverse(tmat3x3<T, P>::_null);
Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
return Inverse;
}
}//namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x3<T, P>::length() const
{
@ -195,7 +218,7 @@ namespace detail
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
}
template <typename T, precision P>
@ -217,7 +240,7 @@ namespace detail
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
}
template <typename T, precision P>
@ -239,7 +262,7 @@ namespace detail
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
}
template <typename T, precision P>
@ -368,7 +391,7 @@ namespace detail
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/= (tmat3x3<U, P> const & m)
{
return (*this = *this * detail::compute_inverse<detail::tmat3x3, T, P>::call(m));
return (*this = *this * detail::compute_inverse<T, P>(m));
}
template <typename T, precision P>
@ -405,31 +428,6 @@ namespace detail
return Result;
}
template <typename T, precision P>
struct compute_inverse<detail::tmat3x3, T, P>
{
static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
{
T OneOverDeterminant = static_cast<T>(1) / (
+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
detail::tmat3x3<T, P> Inverse(detail::tmat3x3<T, P>::_null);
Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
return Inverse;
}
};
//////////////////////////////////////////////////////////////
// Binary operators
@ -674,7 +672,7 @@ namespace detail
typename tmat3x3<T, P>::row_type const & v
)
{
return detail::compute_inverse<detail::tmat3x3, T, P>::call(m) * v;
return detail::compute_inverse<tmat3x3, T, P>::call(m) * v;
}
template <typename T, precision P>
@ -684,7 +682,7 @@ namespace detail
tmat3x3<T, P> const & m
)
{
return v * detail::compute_inverse<detail::tmat3x3, T, P>::call(m);
return v * detail::compute_inverse<tmat3x3, T, P>::call(m);
}
template <typename T, precision P>
@ -733,6 +731,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat3x4.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat3x4
@ -210,8 +209,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> const operator-(
tmat3x4<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

18
glm/detail/type_mat3x4.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x4<T, P>::length() const
@ -189,8 +188,8 @@ namespace detail
tmat2x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
this->value[2] = col_type(T(0), T(0), T(1), T(0));
}
@ -233,8 +232,8 @@ namespace detail
tmat3x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
this->value[2] = col_type(m[2], T(0), T(1));
}
@ -255,9 +254,9 @@ namespace detail
tmat4x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(T(0)));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(T(0)));
this->value[2] = col_type(m[2], detail::tvec2<T, P>(T(1), T(0)));
this->value[0] = col_type(m[0], tvec2<T, P>(T(0)));
this->value[1] = col_type(m[1], tvec2<T, P>(T(0)));
this->value[2] = col_type(m[2], tvec2<T, P>(T(1), T(0)));
}
template <typename T, precision P>
@ -649,5 +648,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat4x2.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat4x2
@ -216,8 +215,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> const operator-(
tmat4x2<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

4
glm/detail/type_mat4x2.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x2<T, P>::length() const
@ -668,5 +667,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat4x3.hpp
View file

@ -41,8 +41,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat4x3
@ -216,8 +215,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> const operator- (
tmat4x3<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

4
glm/detail/type_mat4x3.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x3<T, P>::length() const
@ -699,6 +698,5 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm

5
glm/detail/type_mat4x4.hpp
View file

@ -34,8 +34,7 @@
#include <limits>
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tmat4x4
@ -244,8 +243,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> const operator- (
tmat4x4<T, P> const & m);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

144
glm/detail/type_mat4x4.inl
View file

@ -29,6 +29,65 @@
namespace glm{
namespace detail
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat4x4<T, P> compute_inverse(tmat4x4<T, P> const & m)
{
T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
tvec4<T, P> SignA(+1, -1, +1, -1);
tvec4<T, P> SignB(-1, +1, -1, +1);
tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
tvec4<T, P> Dot0(m[0] * Row0);
T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
T OneOverDeterminant = static_cast<T>(1) / Dot1;
return Inverse * OneOverDeterminant;
}
}//namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x4<T, P>::length() const
{
@ -233,8 +292,8 @@ namespace detail
tmat2x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
this->value[2] = col_type(static_cast<T>(0));
this->value[3] = col_type(static_cast<T>(0), value_type(0), value_type(0), value_type(1));
}
@ -269,9 +328,9 @@ namespace detail
tmat3x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[2] = col_type(m[2], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
this->value[2] = col_type(m[2], tvec2<T, P>(0));
this->value[3] = col_type(static_cast<T>(0), value_type(0), value_type(0), value_type(1));
}
@ -293,8 +352,8 @@ namespace detail
tmat4x2<T, P> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
this->value[0] = col_type(m[0], tvec2<T, P>(0));
this->value[1] = col_type(m[1], tvec2<T, P>(0));
this->value[2] = col_type(T(0));
this->value[3] = col_type(T(0), T(0), T(0), T(1));
}
@ -434,7 +493,7 @@ namespace detail
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/= (tmat4x4<U, P> const & m)
{
return (*this = *this * detail::compute_inverse<detail::tmat4x4, T, P>::call(m));
return (*this = *this * detail::compute_inverse<T, P>(m));
}
template <typename T, precision P>
@ -473,67 +532,6 @@ namespace detail
return Result;
}
template <typename T, precision P>
struct compute_inverse<detail::tmat4x4, T, P>
{
static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
{
T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
detail::tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
detail::tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
detail::tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
detail::tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
detail::tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
detail::tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
detail::tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
detail::tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
detail::tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
detail::tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
detail::tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
detail::tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
detail::tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
detail::tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
detail::tvec4<T, P> SignA(+1, -1, +1, -1);
detail::tvec4<T, P> SignB(-1, +1, -1, +1);
detail::tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
detail::tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
detail::tvec4<T, P> Dot0(m[0] * Row0);
T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
T OneOverDeterminant = static_cast<T>(1) / Dot1;
return Inverse * OneOverDeterminant;
}
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+
@ -809,7 +807,7 @@ namespace detail
typename tmat4x4<T, P>::row_type const & v
)
{
return detail::compute_inverse<detail::tmat4x4, T, P>::call(m) * v;
return detail::compute_inverse<tmat4x4, T, P>::call(m) * v;
}
template <typename T, precision P>
@ -819,7 +817,7 @@ namespace detail
tmat4x4<T, P> const & m
)
{
return v * detail::compute_inverse<detail::tmat4x4, T, P>::call(m);
return v * detail::compute_inverse<tmat4x4, T, P>::call(m);
}
template <typename T, precision P>
@ -897,6 +895,4 @@ namespace detail
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm
}//namespace glm

232
glm/detail/type_vec.hpp
View file

@ -22,7 +22,7 @@
///
/// @ref core
/// @file glm/core/type_vec.hpp
/// @date 2010-01-26 / 2011-06-15
/// @date 2010-01-26 / 2014-10-05
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
@ -31,246 +31,244 @@
#include "precision.hpp"
#include "type_int.hpp"
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P> struct tvec1;
template <typename T, precision P> struct tvec2;
template <typename T, precision P> struct tvec3;
template <typename T, precision P> struct tvec4;
}//namespace detail
typedef detail::tvec1<float, highp> highp_vec1_t;
typedef detail::tvec1<float, mediump> mediump_vec1_t;
typedef detail::tvec1<float, lowp> lowp_vec1_t;
typedef detail::tvec1<int, highp> highp_ivec1_t;
typedef detail::tvec1<int, mediump> mediump_ivec1_t;
typedef detail::tvec1<int, lowp> lowp_ivec1_t;
typedef detail::tvec1<uint, highp> highp_uvec1_t;
typedef detail::tvec1<uint, mediump> mediump_uvec1_t;
typedef detail::tvec1<uint, lowp> lowp_uvec1_t;
typedef detail::tvec1<bool, highp> highp_bvec1_t;
typedef detail::tvec1<bool, mediump> mediump_bvec1_t;
typedef detail::tvec1<bool, lowp> lowp_bvec1_t;
typedef tvec1<float, highp> highp_vec1_t;
typedef tvec1<float, mediump> mediump_vec1_t;
typedef tvec1<float, lowp> lowp_vec1_t;
typedef tvec1<int, highp> highp_ivec1_t;
typedef tvec1<int, mediump> mediump_ivec1_t;
typedef tvec1<int, lowp> lowp_ivec1_t;
typedef tvec1<uint, highp> highp_uvec1_t;
typedef tvec1<uint, mediump> mediump_uvec1_t;
typedef tvec1<uint, lowp> lowp_uvec1_t;
typedef tvec1<bool, highp> highp_bvec1_t;
typedef tvec1<bool, mediump> mediump_bvec1_t;
typedef tvec1<bool, lowp> lowp_bvec1_t;
/// @addtogroup core_precision
/// @{
/// 2 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, highp> highp_vec2;
typedef tvec2<float, highp> highp_vec2;
/// 2 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, mediump> mediump_vec2;
typedef tvec2<float, mediump> mediump_vec2;
/// 2 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, lowp> lowp_vec2;
typedef tvec2<float, lowp> lowp_vec2;
/// 2 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, highp> highp_dvec2;
typedef tvec2<double, highp> highp_dvec2;
/// 2 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, mediump> mediump_dvec2;
typedef tvec2<double, mediump> mediump_dvec2;
/// 2 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, lowp> lowp_dvec2;
typedef tvec2<double, lowp> lowp_dvec2;
/// 2 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<int, highp> highp_ivec2;
typedef tvec2<int, highp> highp_ivec2;
/// 2 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<int, mediump> mediump_ivec2;
typedef tvec2<int, mediump> mediump_ivec2;
/// 2 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<int, lowp> lowp_ivec2;
typedef tvec2<int, lowp> lowp_ivec2;
/// 2 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<uint, highp> highp_uvec2;
typedef tvec2<uint, highp> highp_uvec2;
/// 2 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<uint, mediump> mediump_uvec2;
typedef tvec2<uint, mediump> mediump_uvec2;
/// 2 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<uint, lowp> lowp_uvec2;
typedef tvec2<uint, lowp> lowp_uvec2;
/// 2 components vector of high precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, highp> highp_bvec2;
typedef tvec2<bool, highp> highp_bvec2;
/// 2 components vector of medium precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, mediump> mediump_bvec2;
typedef tvec2<bool, mediump> mediump_bvec2;
/// 2 components vector of low precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, lowp> lowp_bvec2;
typedef tvec2<bool, lowp> lowp_bvec2;
/// @}
/// @addtogroup core_precision
/// @{
/// 3 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, highp> highp_vec3;
typedef tvec3<float, highp> highp_vec3;
/// 3 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, mediump> mediump_vec3;
typedef tvec3<float, mediump> mediump_vec3;
/// 3 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, lowp> lowp_vec3;
typedef tvec3<float, lowp> lowp_vec3;
/// 3 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, highp> highp_dvec3;
typedef tvec3<double, highp> highp_dvec3;
/// 3 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, mediump> mediump_dvec3;
typedef tvec3<double, mediump> mediump_dvec3;
/// 3 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, lowp> lowp_dvec3;
typedef tvec3<double, lowp> lowp_dvec3;
/// 3 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<int, highp> highp_ivec3;
typedef tvec3<int, highp> highp_ivec3;
/// 3 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<int, mediump> mediump_ivec3;
typedef tvec3<int, mediump> mediump_ivec3;
/// 3 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<int, lowp> lowp_ivec3;
typedef tvec3<int, lowp> lowp_ivec3;
/// 3 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<uint, highp> highp_uvec3;
typedef tvec3<uint, highp> highp_uvec3;
/// 3 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<uint, mediump> mediump_uvec3;
typedef tvec3<uint, mediump> mediump_uvec3;
/// 3 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<uint, lowp> lowp_uvec3;
typedef tvec3<uint, lowp> lowp_uvec3;
/// 3 components vector of high precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, highp> highp_bvec3;
typedef tvec3<bool, highp> highp_bvec3;
/// 3 components vector of medium precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, mediump> mediump_bvec3;
typedef tvec3<bool, mediump> mediump_bvec3;
/// 3 components vector of low precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, lowp> lowp_bvec3;
typedef tvec3<bool, lowp> lowp_bvec3;
/// @}
/// @addtogroup core_precision
/// @{
@ -278,100 +276,100 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, highp> highp_vec4;
typedef tvec4<float, highp> highp_vec4;
/// 4 components vector of medium single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, mediump> mediump_vec4;
typedef tvec4<float, mediump> mediump_vec4;
/// 4 components vector of low single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, lowp> lowp_vec4;
typedef tvec4<float, lowp> lowp_vec4;
/// 4 components vector of high double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, highp> highp_dvec4;
typedef tvec4<double, highp> highp_dvec4;
/// 4 components vector of medium double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, mediump> mediump_dvec4;
typedef tvec4<double, mediump> mediump_dvec4;
/// 4 components vector of low double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, lowp> lowp_dvec4;
typedef tvec4<double, lowp> lowp_dvec4;
/// 4 components vector of high precision signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, highp> highp_ivec4;
typedef tvec4<int, highp> highp_ivec4;
/// 4 components vector of medium precision signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, mediump> mediump_ivec4;
typedef tvec4<int, mediump> mediump_ivec4;
/// 4 components vector of low precision signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, lowp> lowp_ivec4;
typedef tvec4<int, lowp> lowp_ivec4;
/// 4 components vector of high precision unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, highp> highp_uvec4;
typedef tvec4<uint, highp> highp_uvec4;
/// 4 components vector of medium precision unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, mediump> mediump_uvec4;
typedef tvec4<uint, mediump> mediump_uvec4;
/// 4 components vector of low precision unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, lowp> lowp_uvec4;
typedef tvec4<uint, lowp> lowp_uvec4;
/// 4 components vector of high precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, highp> highp_bvec4;
typedef tvec4<bool, highp> highp_bvec4;
/// 4 components vector of medium precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, mediump> mediump_bvec4;
typedef tvec4<bool, mediump> mediump_bvec4;
/// 4 components vector of low precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, lowp> lowp_bvec4;
typedef tvec4<bool, lowp> lowp_bvec4;
/// @}
/// @addtogroup core_types
/// @{
//////////////////////////
// Default float definition
#if(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_vec2 vec2;
typedef lowp_vec3 vec3;
@ -385,12 +383,12 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_vec2 vec2;
//! 3 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_vec3 vec3;
//! 4 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
@ -399,7 +397,7 @@ namespace detail
//////////////////////////
// Default double definition
#if(defined(GLM_PRECISION_LOWP_DOUBLE))
typedef lowp_dvec2 dvec2;
typedef lowp_dvec3 dvec3;

5
glm/detail/type_vec1.hpp
View file

@ -39,8 +39,7 @@
#endif //GLM_SWIZZLE
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tvec1
@ -264,8 +263,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

5
glm/detail/type_vec1.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec1<T, P>::length() const
@ -807,6 +806,4 @@ namespace detail
return tvec1<T, P>(
~v.x);
}
}//namespace detail
}//namespace glm

7
glm/detail/type_vec2.hpp
View file

@ -39,8 +39,7 @@
#endif //GLM_SWIZZLE
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tvec2
@ -85,7 +84,7 @@ namespace detail
union {T y, g, t;};
# ifdef GLM_SWIZZLE
GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
# endif
# endif
@ -379,8 +378,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

5
glm/detail/type_vec2.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec2<T, P>::length() const
@ -910,6 +909,4 @@ namespace detail
~v.x,
~v.y);
}
}//namespace detail
}//namespace glm

7
glm/detail/type_vec3.hpp
View file

@ -39,8 +39,7 @@
#endif //GLM_SWIZZLE
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
struct tvec3
@ -86,7 +85,7 @@ namespace detail
union { T z, b, p; };
# ifdef GLM_SWIZZLE
GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
# endif
# endif//GLM_LANG
@ -396,8 +395,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

5
glm/detail/type_vec3.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec3<T, P>::length() const
@ -876,6 +875,4 @@ namespace detail
~v.y,
~v.z);
}
}//namespace detail
}//namespace glm

7
glm/detail/type_vec4.hpp
View file

@ -40,8 +40,7 @@
#endif //GLM_SWIZZLE
#include <cstddef>
namespace glm{
namespace detail
namespace glm
{
template <typename T>
struct simd
@ -125,7 +124,7 @@ namespace detail
# endif
# ifdef GLM_SWIZZLE
GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
# endif
# endif//GLM_LANG
@ -410,8 +409,6 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE

5
glm/detail/type_vec4.inl
View file

@ -26,8 +26,7 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec4<T, P>::length() const
@ -1159,6 +1158,4 @@ namespace detail
~v.z,
~v.w);
}
}//namespace detail
}//namespace glm

5
glm/ext.hpp
View file

@ -128,8 +128,11 @@
#include "./gtx/vector_query.hpp"
#include "./gtx/wrap.hpp"
#if GLM_LANG & GLM_LANG_CXX0X_FLAG
#if GLM_HAS_TEMPLATE_ALIASES
# include "./gtx/scalar_multiplication.hpp"
#endif
#if GLM_HAS_RANGE_FOR
# include "./gtx/range.hpp"
#endif

543
glm/fwd.hpp
View file

File diff suppressed because it is too large Load diff

20
glm/gtc/epsilon.inl
View file

@ -125,26 +125,26 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> epsilonEqual
GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonEqual
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & epsilon
)
{
detail::tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return lessThan(abs(v), detail::tvec4<T, P>(epsilon));
tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return lessThan(abs(v), tvec4<T, P>(epsilon));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> epsilonNotEqual
GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonNotEqual
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & epsilon
)
{
detail::tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return greaterThanEqual(abs(v), detail::tvec4<T, P>(epsilon));
tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return greaterThanEqual(abs(v), tvec4<T, P>(epsilon));
}
}//namespace glm

144
glm/gtc/matrix_integer.hpp
View file

@ -58,300 +58,300 @@ namespace glm
/// High-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, highp> highp_imat2;
typedef tmat2x2<int, highp> highp_imat2;
/// High-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, highp> highp_imat3;
typedef tmat3x3<int, highp> highp_imat3;
/// High-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, highp> highp_imat4;
typedef tmat4x4<int, highp> highp_imat4;
/// High-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, highp> highp_imat2x2;
typedef tmat2x2<int, highp> highp_imat2x2;
/// High-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<int, highp> highp_imat2x3;
typedef tmat2x3<int, highp> highp_imat2x3;
/// High-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<int, highp> highp_imat2x4;
typedef tmat2x4<int, highp> highp_imat2x4;
/// High-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<int, highp> highp_imat3x2;
typedef tmat3x2<int, highp> highp_imat3x2;
/// High-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, highp> highp_imat3x3;
typedef tmat3x3<int, highp> highp_imat3x3;
/// High-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<int, highp> highp_imat3x4;
typedef tmat3x4<int, highp> highp_imat3x4;
/// High-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<int, highp> highp_imat4x2;
typedef tmat4x2<int, highp> highp_imat4x2;
/// High-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<int, highp> highp_imat4x3;
typedef tmat4x3<int, highp> highp_imat4x3;
/// High-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, highp> highp_imat4x4;
typedef tmat4x4<int, highp> highp_imat4x4;
/// Medium-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, mediump> mediump_imat2;
typedef tmat2x2<int, mediump> mediump_imat2;
/// Medium-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, mediump> mediump_imat3;
typedef tmat3x3<int, mediump> mediump_imat3;
/// Medium-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, mediump> mediump_imat4;
typedef tmat4x4<int, mediump> mediump_imat4;
/// Medium-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, mediump> mediump_imat2x2;
typedef tmat2x2<int, mediump> mediump_imat2x2;
/// Medium-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<int, mediump> mediump_imat2x3;
typedef tmat2x3<int, mediump> mediump_imat2x3;
/// Medium-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<int, mediump> mediump_imat2x4;
typedef tmat2x4<int, mediump> mediump_imat2x4;
/// Medium-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<int, mediump> mediump_imat3x2;
typedef tmat3x2<int, mediump> mediump_imat3x2;
/// Medium-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, mediump> mediump_imat3x3;
typedef tmat3x3<int, mediump> mediump_imat3x3;
/// Medium-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<int, mediump> mediump_imat3x4;
typedef tmat3x4<int, mediump> mediump_imat3x4;
/// Medium-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<int, mediump> mediump_imat4x2;
typedef tmat4x2<int, mediump> mediump_imat4x2;
/// Medium-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<int, mediump> mediump_imat4x3;
typedef tmat4x3<int, mediump> mediump_imat4x3;
/// Medium-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, mediump> mediump_imat4x4;
typedef tmat4x4<int, mediump> mediump_imat4x4;
/// Low-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, lowp> lowp_imat2;
typedef tmat2x2<int, lowp> lowp_imat2;
/// Low-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, lowp> lowp_imat3;
typedef tmat3x3<int, lowp> lowp_imat3;
/// Low-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, lowp> lowp_imat4;
typedef tmat4x4<int, lowp> lowp_imat4;
/// Low-precision signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<int, lowp> lowp_imat2x2;
typedef tmat2x2<int, lowp> lowp_imat2x2;
/// Low-precision signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<int, lowp> lowp_imat2x3;
typedef tmat2x3<int, lowp> lowp_imat2x3;
/// Low-precision signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<int, lowp> lowp_imat2x4;
typedef tmat2x4<int, lowp> lowp_imat2x4;
/// Low-precision signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<int, lowp> lowp_imat3x2;
typedef tmat3x2<int, lowp> lowp_imat3x2;
/// Low-precision signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<int, lowp> lowp_imat3x3;
typedef tmat3x3<int, lowp> lowp_imat3x3;
/// Low-precision signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<int, lowp> lowp_imat3x4;
typedef tmat3x4<int, lowp> lowp_imat3x4;
/// Low-precision signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<int, lowp> lowp_imat4x2;
typedef tmat4x2<int, lowp> lowp_imat4x2;
/// Low-precision signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<int, lowp> lowp_imat4x3;
typedef tmat4x3<int, lowp> lowp_imat4x3;
/// Low-precision signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<int, lowp> lowp_imat4x4;
typedef tmat4x4<int, lowp> lowp_imat4x4;
/// High-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, highp> highp_umat2;
typedef tmat2x2<uint, highp> highp_umat2;
/// High-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, highp> highp_umat3;
typedef tmat3x3<uint, highp> highp_umat3;
/// High-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, highp> highp_umat4;
typedef tmat4x4<uint, highp> highp_umat4;
/// High-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, highp> highp_umat2x2;
typedef tmat2x2<uint, highp> highp_umat2x2;
/// High-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<uint, highp> highp_umat2x3;
typedef tmat2x3<uint, highp> highp_umat2x3;
/// High-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<uint, highp> highp_umat2x4;
typedef tmat2x4<uint, highp> highp_umat2x4;
/// High-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<uint, highp> highp_umat3x2;
typedef tmat3x2<uint, highp> highp_umat3x2;
/// High-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, highp> highp_umat3x3;
typedef tmat3x3<uint, highp> highp_umat3x3;
/// High-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<uint, highp> highp_umat3x4;
typedef tmat3x4<uint, highp> highp_umat3x4;
/// High-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<uint, highp> highp_umat4x2;
typedef tmat4x2<uint, highp> highp_umat4x2;
/// High-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<uint, highp> highp_umat4x3;
typedef tmat4x3<uint, highp> highp_umat4x3;
/// High-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, highp> highp_umat4x4;
typedef tmat4x4<uint, highp> highp_umat4x4;
/// Medium-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, mediump> mediump_umat2;
typedef tmat2x2<uint, mediump> mediump_umat2;
/// Medium-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, mediump> mediump_umat3;
typedef tmat3x3<uint, mediump> mediump_umat3;
/// Medium-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, mediump> mediump_umat4;
typedef tmat4x4<uint, mediump> mediump_umat4;
/// Medium-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, mediump> mediump_umat2x2;
typedef tmat2x2<uint, mediump> mediump_umat2x2;
/// Medium-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<uint, mediump> mediump_umat2x3;
typedef tmat2x3<uint, mediump> mediump_umat2x3;
/// Medium-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<uint, mediump> mediump_umat2x4;
typedef tmat2x4<uint, mediump> mediump_umat2x4;
/// Medium-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<uint, mediump> mediump_umat3x2;
typedef tmat3x2<uint, mediump> mediump_umat3x2;
/// Medium-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, mediump> mediump_umat3x3;
typedef tmat3x3<uint, mediump> mediump_umat3x3;
/// Medium-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<uint, mediump> mediump_umat3x4;
typedef tmat3x4<uint, mediump> mediump_umat3x4;
/// Medium-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<uint, mediump> mediump_umat4x2;
typedef tmat4x2<uint, mediump> mediump_umat4x2;
/// Medium-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<uint, mediump> mediump_umat4x3;
typedef tmat4x3<uint, mediump> mediump_umat4x3;
/// Medium-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, mediump> mediump_umat4x4;
typedef tmat4x4<uint, mediump> mediump_umat4x4;
/// Low-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, lowp> lowp_umat2;
typedef tmat2x2<uint, lowp> lowp_umat2;
/// Low-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, lowp> lowp_umat3;
typedef tmat3x3<uint, lowp> lowp_umat3;
/// Low-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, lowp> lowp_umat4;
typedef tmat4x4<uint, lowp> lowp_umat4;
/// Low-precision unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x2<uint, lowp> lowp_umat2x2;
typedef tmat2x2<uint, lowp> lowp_umat2x2;
/// Low-precision unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x3<uint, lowp> lowp_umat2x3;
typedef tmat2x3<uint, lowp> lowp_umat2x3;
/// Low-precision unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat2x4<uint, lowp> lowp_umat2x4;
typedef tmat2x4<uint, lowp> lowp_umat2x4;
/// Low-precision unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x2<uint, lowp> lowp_umat3x2;
typedef tmat3x2<uint, lowp> lowp_umat3x2;
/// Low-precision unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x3<uint, lowp> lowp_umat3x3;
typedef tmat3x3<uint, lowp> lowp_umat3x3;
/// Low-precision unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat3x4<uint, lowp> lowp_umat3x4;
typedef tmat3x4<uint, lowp> lowp_umat3x4;
/// Low-precision unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x2<uint, lowp> lowp_umat4x2;
typedef tmat4x2<uint, lowp> lowp_umat4x2;
/// Low-precision unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x3<uint, lowp> lowp_umat4x3;
typedef tmat4x3<uint, lowp> lowp_umat4x3;
/// Low-precision unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef detail::tmat4x4<uint, lowp> lowp_umat4x4;
typedef tmat4x4<uint, lowp> lowp_umat4x4;
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_imat2 imat2;

38
glm/gtc/matrix_inverse.inl
View file

@ -33,42 +33,42 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> affineInverse
GLM_FUNC_QUALIFIER tmat3x3<T, P> affineInverse
(
detail::tmat3x3<T, P> const & m
tmat3x3<T, P> const & m
)
{
detail::tmat3x3<T, P> Result(m);
Result[2] = detail::tvec3<T, P>(0, 0, 1);
tmat3x3<T, P> Result(m);
Result[2] = tvec3<T, P>(0, 0, 1);
Result = transpose(Result);
detail::tvec3<T, P> Translation = Result * detail::tvec3<T, P>(-detail::tvec2<T, P>(m[2]), m[2][2]);
tvec3<T, P> Translation = Result * tvec3<T, P>(-tvec2<T, P>(m[2]), m[2][2]);
Result[2] = Translation;
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> affineInverse
GLM_FUNC_QUALIFIER tmat4x4<T, P> affineInverse
(
detail::tmat4x4<T, P> const & m
tmat4x4<T, P> const & m
)
{
detail::tmat4x4<T, P> Result(m);
Result[3] = detail::tvec4<T, P>(0, 0, 0, 1);
tmat4x4<T, P> Result(m);
Result[3] = tvec4<T, P>(0, 0, 0, 1);
Result = transpose(Result);
detail::tvec4<T, P> Translation = Result * detail::tvec4<T, P>(-detail::tvec3<T, P>(m[3]), m[3][3]);
tvec4<T, P> Translation = Result * tvec4<T, P>(-tvec3<T, P>(m[3]), m[3][3]);
Result[3] = Translation;
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> inverseTranspose
GLM_FUNC_QUALIFIER tmat2x2<T, P> inverseTranspose
(
detail::tmat2x2<T, P> const & m
tmat2x2<T, P> const & m
)
{
T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
detail::tmat2x2<T, P> Inverse(
tmat2x2<T, P> Inverse(
+ m[1][1] / Determinant,
- m[0][1] / Determinant,
- m[1][0] / Determinant,
@ -78,9 +78,9 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> inverseTranspose
GLM_FUNC_QUALIFIER tmat3x3<T, P> inverseTranspose
(
detail::tmat3x3<T, P> const & m
tmat3x3<T, P> const & m
)
{
T Determinant =
@ -88,7 +88,7 @@ namespace glm
- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
detail::tmat3x3<T, P> Inverse;
tmat3x3<T, P> Inverse;
Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
@ -104,9 +104,9 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> inverseTranspose
GLM_FUNC_QUALIFIER tmat4x4<T, P> inverseTranspose
(
detail::tmat4x4<T, P> const & m
tmat4x4<T, P> const & m
)
{
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
@ -129,7 +129,7 @@ namespace glm
T SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
T SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
detail::tmat4x4<T, P> Inverse;
tmat4x4<T, P> Inverse;
Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);

82
glm/gtc/matrix_transform.hpp
View file

@ -79,12 +79,12 @@ namespace glm
/// @see gtc_matrix_transform
/// @see gtx_transform
/// @see - translate(T x, T y, T z)
/// @see - translate(detail::tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - translate(detail::tvec3<T, P> const & v)
/// @see - translate(tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - translate(tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> translate(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat4x4<T, P> translate(
tmat4x4<T, P> const & m,
tvec3<T, P> const & v);
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
///
@ -95,13 +95,13 @@ namespace glm
/// @see gtc_matrix_transform
/// @see gtx_transform
/// @see - rotate(T angle, T x, T y, T z)
/// @see - rotate(detail::tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, detail::tvec3<T, P> const & v)
/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rotate(
detail::tmat4x4<T, P> const & m,
GLM_FUNC_DECL tmat4x4<T, P> rotate(
tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & axis);
tvec3<T, P> const & axis);
/// Builds a scale 4 * 4 matrix created from 3 scalars.
///
@ -111,12 +111,12 @@ namespace glm
/// @see gtc_matrix_transform
/// @see gtx_transform
/// @see - scale(T x, T y, T z) scale(T const & x, T const & y, T const & z)
/// @see - scale(detail::tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - scale(detail::tvec3<T, P> const & v)
/// @see - scale(tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - scale(tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> scale(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat4x4<T, P> scale(
tmat4x4<T, P> const & m,
tvec3<T, P> const & v);
/// Creates a matrix for an orthographic parallel viewing volume.
///
@ -130,7 +130,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
T const & left,
T const & right,
T const & bottom,
@ -148,7 +148,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
T const & left,
T const & right,
T const & bottom,
@ -165,7 +165,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> frustum(
GLM_FUNC_DECL tmat4x4<T, defaultp> frustum(
T const & left,
T const & right,
T const & bottom,
@ -182,7 +182,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> perspective(
GLM_FUNC_DECL tmat4x4<T, defaultp> perspective(
T const & fovy,
T const & aspect,
T const & near,
@ -198,7 +198,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> perspectiveFov(
GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFov(
T const & fov,
T const & width,
T const & height,
@ -213,7 +213,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> infinitePerspective(
GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspective(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@ -224,7 +224,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> tweakedInfinitePerspective(
GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@ -235,7 +235,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> tweakedInfinitePerspective(
GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near, T ep);
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
@ -248,11 +248,11 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, typename U, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> project(
detail::tvec3<T, P> const & obj,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
detail::tvec4<U, P> const & viewport);
GLM_FUNC_DECL tvec3<T, P> project(
tvec3<T, P> const & obj,
tmat4x4<T, P> const & model,
tmat4x4<T, P> const & proj,
tvec4<U, P> const & viewport);
/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
///
@ -264,11 +264,11 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, typename U, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> unProject(
detail::tvec3<T, P> const & win,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
detail::tvec4<U, P> const & viewport);
GLM_FUNC_DECL tvec3<T, P> unProject(
tvec3<T, P> const & win,
tmat4x4<T, P> const & model,
tmat4x4<T, P> const & proj,
tvec4<U, P> const & viewport);
/// Define a picking region
///
@ -279,10 +279,10 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, precision P, typename U>
GLM_FUNC_DECL detail::tmat4x4<T, P> pickMatrix(
detail::tvec2<T, P> const & center,
detail::tvec2<T, P> const & delta,
detail::tvec4<U, P> const & viewport);
GLM_FUNC_DECL tmat4x4<T, P> pickMatrix(
tvec2<T, P> const & center,
tvec2<T, P> const & delta,
tvec4<U, P> const & viewport);
/// Build a look at view matrix.
///
@ -292,10 +292,10 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> lookAt(
detail::tvec3<T, P> const & eye,
detail::tvec3<T, P> const & center,
detail::tvec3<T, P> const & up);
GLM_FUNC_DECL tmat4x4<T, P> lookAt(
tvec3<T, P> const & eye,
tvec3<T, P> const & center,
tvec3<T, P> const & up);
/// @}
}//namespace glm

142
glm/gtc/matrix_transform.inl
View file

@ -33,33 +33,33 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> translate
GLM_FUNC_QUALIFIER tmat4x4<T, P> translate
(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v
tmat4x4<T, P> const & m,
tvec3<T, P> const & v
)
{
detail::tmat4x4<T, P> Result(m);
tmat4x4<T, P> Result(m);
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate
GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate
(
detail::tmat4x4<T, P> const & m,
tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
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);
tvec3<T, P> axis(normalize(v));
tvec3<T, P> temp((T(1) - c) * axis);
detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> Rotate(tmat4x4<T, P>::_null);
Rotate[0][0] = c + temp[0] * axis[0];
Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
@ -72,7 +72,7 @@ namespace glm
Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
Rotate[2][2] = c + temp[2] * axis[2];
detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> Result(tmat4x4<T, P>::_null);
Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
@ -81,19 +81,19 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate_slow
GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate_slow
(
detail::tmat4x4<T, P> const & m,
tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tmat4x4<T, P> Result;
tmat4x4<T, P> Result;
detail::tvec3<T, P> axis = normalize(v);
tvec3<T, P> axis = normalize(v);
Result[0][0] = c + (1 - c) * axis.x * axis.x;
Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
@ -110,18 +110,18 @@ namespace glm
Result[2][2] = c + (1 - c) * axis.z * axis.z;
Result[2][3] = 0;
Result[3] = detail::tvec4<T, P>(0, 0, 0, 1);
Result[3] = tvec4<T, P>(0, 0, 0, 1);
return m * Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> scale
GLM_FUNC_QUALIFIER tmat4x4<T, P> scale
(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v
tmat4x4<T, P> const & m,
tvec3<T, P> const & v
)
{
detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> Result(tmat4x4<T, P>::_null);
Result[0] = m[0] * v[0];
Result[1] = m[1] * v[1];
Result[2] = m[2] * v[2];
@ -130,13 +130,13 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> scale_slow
GLM_FUNC_QUALIFIER tmat4x4<T, P> scale_slow
(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v
tmat4x4<T, P> const & m,
tvec3<T, P> const & v
)
{
detail::tmat4x4<T, P> Result(T(1));
tmat4x4<T, P> Result(T(1));
Result[0][0] = v.x;
Result[1][1] = v.y;
Result[2][2] = v.z;
@ -144,7 +144,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> ortho
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
(
T const & left,
T const & right,
@ -154,7 +154,7 @@ namespace glm
T const & zFar
)
{
detail::tmat4x4<T, defaultp> Result(1);
tmat4x4<T, defaultp> Result(1);
Result[0][0] = static_cast<T>(2) / (right - left);
Result[1][1] = static_cast<T>(2) / (top - bottom);
Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
@ -165,7 +165,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> ortho
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
(
T const & left,
T const & right,
@ -173,7 +173,7 @@ namespace glm
T const & top
)
{
detail::tmat4x4<T, defaultp> Result(1);
tmat4x4<T, defaultp> Result(1);
Result[0][0] = static_cast<T>(2) / (right - left);
Result[1][1] = static_cast<T>(2) / (top - bottom);
Result[2][2] = - static_cast<T>(1);
@ -183,7 +183,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> frustum
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> frustum
(
T const & left,
T const & right,
@ -193,7 +193,7 @@ namespace glm
T const & farVal
)
{
detail::tmat4x4<T, defaultp> Result(0);
tmat4x4<T, defaultp> Result(0);
Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
Result[2][0] = (right + left) / (right - left);
@ -205,7 +205,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> perspective
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspective
(
T const & fovy,
T const & aspect,
@ -219,7 +219,7 @@ namespace glm
T const rad = fovy;
T const tanHalfFovy = tan(rad / static_cast<T>(2));
detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
tmat4x4<T, defaultp> Result(static_cast<T>(0));
Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
Result[2][2] = - (zFar + zNear) / (zFar - zNear);
@ -229,7 +229,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> perspectiveFov
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFov
(
T const & fov,
T const & width,
@ -246,7 +246,7 @@ namespace glm
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));
tmat4x4<T, defaultp> Result(static_cast<T>(0));
Result[0][0] = w;
Result[1][1] = h;
Result[2][2] = - (zFar + zNear) / (zFar - zNear);
@ -256,7 +256,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> infinitePerspective
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspective
(
T fovy,
T aspect,
@ -269,7 +269,7 @@ namespace glm
T const bottom = -range;
T const top = range;
detail::tmat4x4<T, defaultp> Result(T(0));
tmat4x4<T, defaultp> Result(T(0));
Result[0][0] = (T(2) * zNear) / (right - left);
Result[1][1] = (T(2) * zNear) / (top - bottom);
Result[2][2] = - T(1);
@ -280,7 +280,7 @@ namespace glm
// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> tweakedInfinitePerspective
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
(
T fovy,
T aspect,
@ -294,7 +294,7 @@ namespace glm
T const bottom = -range;
T const top = range;
detail::tmat4x4<T, defaultp> Result(T(0));
tmat4x4<T, defaultp> Result(T(0));
Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
Result[2][2] = ep - static_cast<T>(1);
@ -304,7 +304,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> tweakedInfinitePerspective
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
(
T fovy,
T aspect,
@ -315,15 +315,15 @@ namespace glm
}
template <typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> project
GLM_FUNC_QUALIFIER tvec3<T, P> project
(
detail::tvec3<T, P> const & obj,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
detail::tvec4<U, P> const & viewport
tvec3<T, P> const & obj,
tmat4x4<T, P> const & model,
tmat4x4<T, P> const & proj,
tvec4<U, P> const & viewport
)
{
detail::tvec4<T, P> tmp = detail::tvec4<T, P>(obj, T(1));
tvec4<T, P> tmp = tvec4<T, P>(obj, T(1));
tmp = model * tmp;
tmp = proj * tmp;
@ -332,68 +332,68 @@ namespace glm
tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
return detail::tvec3<T, P>(tmp);
return tvec3<T, P>(tmp);
}
template <typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> unProject
GLM_FUNC_QUALIFIER tvec3<T, P> unProject
(
detail::tvec3<T, P> const & win,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
detail::tvec4<U, P> const & viewport
tvec3<T, P> const & win,
tmat4x4<T, P> const & model,
tmat4x4<T, P> const & proj,
tvec4<U, P> const & viewport
)
{
detail::tmat4x4<T, P> Inverse = inverse(proj * model);
tmat4x4<T, P> Inverse = inverse(proj * model);
detail::tvec4<T, P> tmp = detail::tvec4<T, P>(win, T(1));
tvec4<T, P> tmp = tvec4<T, P>(win, T(1));
tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
tmp = tmp * T(2) - T(1);
detail::tvec4<T, P> obj = Inverse * tmp;
tvec4<T, P> obj = Inverse * tmp;
obj /= obj.w;
return detail::tvec3<T, P>(obj);
return tvec3<T, P>(obj);
}
template <typename T, precision P, typename U>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> pickMatrix
GLM_FUNC_QUALIFIER tmat4x4<T, P> pickMatrix
(
detail::tvec2<T, P> const & center,
detail::tvec2<T, P> const & delta,
detail::tvec4<U, P> const & viewport
tvec2<T, P> const & center,
tvec2<T, P> const & delta,
tvec4<U, P> const & viewport
)
{
assert(delta.x > T(0) && delta.y > T(0));
detail::tmat4x4<T, P> Result(1.0f);
tmat4x4<T, P> Result(1.0f);
if(!(delta.x > T(0) && delta.y > T(0)))
return Result; // Error
detail::tvec3<T, P> Temp(
tvec3<T, P> Temp(
(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
T(0));
// Translate and scale the picked region to the entire window
Result = translate(Result, Temp);
return scale(Result, detail::tvec3<T, P>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
return scale(Result, tvec3<T, P>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> lookAt
GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAt
(
detail::tvec3<T, P> const & eye,
detail::tvec3<T, P> const & center,
detail::tvec3<T, P> const & up
tvec3<T, P> const & eye,
tvec3<T, P> const & center,
tvec3<T, P> const & up
)
{
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));
tvec3<T, P> const f(normalize(center - eye));
tvec3<T, P> const s(normalize(cross(f, up)));
tvec3<T, P> const u(cross(s, f));
detail::tmat4x4<T, P> Result(1);
tmat4x4<T, P> Result(1);
Result[0][0] = s.x;
Result[1][0] = s.y;
Result[2][0] = s.z;

852
glm/gtc/noise.inl
View file

File diff suppressed because it is too large Load diff

179
glm/gtc/quaternion.hpp
View file

@ -50,9 +50,11 @@
# pragma message("GLM: GLM_GTC_quaternion extension included")
#endif
namespace glm{
namespace detail
namespace glm
{
/// @addtogroup gtc_quaternion
/// @{
template <typename T, precision P>
struct tquat
{
@ -89,8 +91,8 @@ namespace detail
/// @see gtc_quaternion
/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
GLM_FUNC_DECL explicit tquat(
detail::tvec3<T, P> const & u,
detail::tvec3<T, P> const & v);
tvec3<T, P> const & u,
tvec3<T, P> const & v);
/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
GLM_FUNC_DECL explicit tquat(
tvec3<T, P> const & eulerAngles);
@ -111,72 +113,67 @@ namespace detail
};
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator- (
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> operator- (
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator+ (
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p);
GLM_FUNC_DECL tquat<T, P> operator+ (
tquat<T, P> const & q,
tquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p);
GLM_FUNC_DECL tquat<T, P> operator* (
tquat<T, P> const & q,
tquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> operator* (
tquat<T, P> const & q,
tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec3<T, P> operator* (
tvec3<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tvec4<T, P> operator* (
tquat<T, P> const & q,
tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec4<T, P> operator* (
tvec4<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
detail::tquat<T, P> const & q,
GLM_FUNC_DECL tquat<T, P> operator* (
tquat<T, P> const & q,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
GLM_FUNC_DECL tquat<T, P> operator* (
T const & s,
detail::tquat<T, P> const & q);
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator/ (
detail::tquat<T, P> const & q,
GLM_FUNC_DECL tquat<T, P> operator/ (
tquat<T, P> const & q,
T const & s);
} //namespace detail
/// @addtogroup gtc_quaternion
/// @{
/// Returns the length of the quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T length(
detail::tquat<T, P> const & q);
tquat<T, P> const & q);
/// Returns the normalized quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> normalize(
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> normalize(
tquat<T, P> const & q);
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
///
@ -195,11 +192,11 @@ namespace detail
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
/// @see - slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a)
/// @see - slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> mix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
GLM_FUNC_DECL tquat<T, P> mix(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a);
/// Linear interpolation of two quaternions.
@ -211,9 +208,9 @@ namespace detail
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> lerp(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
GLM_FUNC_DECL tquat<T, P> lerp(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a);
/// Spherical linear interpolation of two quaternions.
@ -225,24 +222,24 @@ namespace detail
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> slerp(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
GLM_FUNC_DECL tquat<T, P> slerp(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a);
/// Returns the q conjugate.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> conjugate(
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> conjugate(
tquat<T, P> const & q);
/// Returns the q inverse.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> inverse(
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> inverse(
tquat<T, P> const & q);
/// Rotates a quaternion from a vector of 3 components axis and an angle.
///
@ -252,77 +249,77 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotate(
detail::tquat<T, P> const & q,
GLM_FUNC_DECL tquat<T, P> rotate(
tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & axis);
tvec3<T, P> const & axis);
/// Returns euler angles, yitch as x, yaw as y, roll as z.
/// The result is expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> eulerAngles(
detail::tquat<T, P> const & x);
GLM_FUNC_DECL tvec3<T, P> eulerAngles(
tquat<T, P> const & x);
/// 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);
GLM_FUNC_DECL T roll(tquat<T, P> const & x);
/// 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);
GLM_FUNC_DECL T pitch(tquat<T, P> const & x);
/// Returns yaw value of euler angles expressed in radians.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T yaw(detail::tquat<T, P> const & x);
GLM_FUNC_DECL T yaw(tquat<T, P> const & x);
/// Converts a quaternion to a 3 * 3 matrix.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> mat3_cast(
detail::tquat<T, P> const & x);
GLM_FUNC_DECL tmat3x3<T, P> mat3_cast(
tquat<T, P> const & x);
/// Converts a quaternion to a 4 * 4 matrix.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> mat4_cast(
detail::tquat<T, P> const & x);
GLM_FUNC_DECL tmat4x4<T, P> mat4_cast(
tquat<T, P> const & x);
/// Converts a 3 * 3 matrix to a quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
detail::tmat3x3<T, P> const & x);
GLM_FUNC_DECL tquat<T, P> quat_cast(
tmat3x3<T, P> const & x);
/// Converts a 4 * 4 matrix to a quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
detail::tmat4x4<T, P> const & x);
GLM_FUNC_DECL tquat<T, P> quat_cast(
tmat4x4<T, P> const & x);
/// Returns the quaternion rotation angle.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T angle(detail::tquat<T, P> const & x);
GLM_FUNC_DECL T angle(tquat<T, P> const & x);
/// Returns the q rotation axis.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> axis(
detail::tquat<T, P> const & x);
GLM_FUNC_DECL tvec3<T, P> axis(
tquat<T, P> const & x);
/// Build a quaternion from an angle and a normalized axis.
///
@ -331,9 +328,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> angleAxis(
GLM_FUNC_DECL tquat<T, P> angleAxis(
T const & angle,
detail::tvec3<T, P> const & axis);
tvec3<T, P> const & axis);
/// Returns the component-wise comparison result of x < y.
///
@ -341,9 +338,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> lessThan(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> lessThan(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// Returns the component-wise comparison of result x <= y.
///
@ -351,9 +348,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> lessThanEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> lessThanEqual(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// Returns the component-wise comparison of result x > y.
///
@ -361,9 +358,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> greaterThan(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> greaterThan(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// Returns the component-wise comparison of result x >= y.
///
@ -371,9 +368,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> greaterThanEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> greaterThanEqual(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// Returns the component-wise comparison of result x == y.
///
@ -381,9 +378,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> equal(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> equal(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// Returns the component-wise comparison of result x != y.
///
@ -391,9 +388,9 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> notEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
GLM_FUNC_DECL tvec4<bool, P> notEqual(
tquat<T, P> const & x,
tquat<T, P> const & y);
/// @}
} //namespace glm

297
glm/gtc/quaternion.inl
View file

@ -34,6 +34,17 @@
namespace glm{
namespace detail
{
template <typename T, precision P>
struct compute_dot<tquat, T, P>
{
static GLM_FUNC_QUALIFIER T call(tquat<T, P> const & x, tquat<T, P> const & y)
{
tvec4<T, P> tmp(x.x * y.x, x.y * y.y, x.z * y.z, x.w * y.w);
return (tmp.x + tmp.y) + (tmp.z + tmp.w);
}
};
}//namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tquat<T, P>::length() const
{
@ -110,13 +121,13 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat
(
detail::tvec3<T, P> const & u,
detail::tvec3<T, P> const & v
tvec3<T, P> const & u,
tvec3<T, P> const & v
)
{
detail::tvec3<T, P> const LocalW(cross(u, v));
T Dot = detail::compute_dot<detail::tvec3, T, P>::call(u, v);
detail::tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
tvec3<T, P> const LocalW(cross(u, v));
T Dot = detail::compute_dot<tvec3, T, P>::call(u, v);
tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
*this = normalize(q);
}
@ -170,28 +181,25 @@ namespace detail
assert(i >= 0 && i < this->length());
return (&x)[i];
}
}//namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> conjugate
GLM_FUNC_QUALIFIER tquat<T, P> conjugate
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return detail::tquat<T, P>(q.w, -q.x, -q.y, -q.z);
return tquat<T, P>(q.w, -q.x, -q.y, -q.z);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> inverse
GLM_FUNC_QUALIFIER tquat<T, P> inverse
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return conjugate(q) / dot(q, q);
}
namespace detail
{
//////////////////////////////////////////////////////////////
// tquat<valType> operators
@ -249,125 +257,112 @@ namespace detail
return *this;
}
//////////////////////////////////////////////////////////////
// tquat<T, P> external functions
template <typename T, precision P>
struct compute_dot<tquat, T, P>
{
static GLM_FUNC_QUALIFIER T call(tquat<T, P> const & x, tquat<T, P> const & y)
{
tvec4<T, P> tmp(x.x * y.x, x.y * y.y, x.z * y.z, x.w * y.w);
return (tmp.x + tmp.y) + (tmp.z + tmp.w);
}
};
//////////////////////////////////////////////////////////////
// tquat<T, P> external operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator-
GLM_FUNC_QUALIFIER tquat<T, P> operator-
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return detail::tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
return tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator+
GLM_FUNC_QUALIFIER tquat<T, P> operator+
(
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p
tquat<T, P> const & q,
tquat<T, P> const & p
)
{
return detail::tquat<T, P>(q) += p;
return tquat<T, P>(q) += p;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
GLM_FUNC_QUALIFIER tquat<T, P> operator*
(
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p
tquat<T, P> const & q,
tquat<T, P> const & p
)
{
return detail::tquat<T, P>(q) *= p;
return tquat<T, P>(q) *= p;
}
// Transformation
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
GLM_FUNC_QUALIFIER tvec3<T, P> operator*
(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v
tquat<T, P> const & q,
tvec3<T, P> const & v
)
{
detail::tvec3<T, P> const QuatVector(q.x, q.y, q.z);
detail::tvec3<T, P> const uv(glm::cross(QuatVector, v));
detail::tvec3<T, P> const uuv(glm::cross(QuatVector, uv));
tvec3<T, P> const QuatVector(q.x, q.y, q.z);
tvec3<T, P> const uv(glm::cross(QuatVector, v));
tvec3<T, P> const uuv(glm::cross(QuatVector, uv));
return v + ((uv * q.w) + uuv) * static_cast<T>(2);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
GLM_FUNC_QUALIFIER tvec3<T, P> operator*
(
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q
tvec3<T, P> const & v,
tquat<T, P> const & q
)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
GLM_FUNC_QUALIFIER tvec4<T, P> operator*
(
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v
tquat<T, P> const & q,
tvec4<T, P> const & v
)
{
return detail::tvec4<T, P>(q * detail::tvec3<T, P>(v), v.w);
return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
GLM_FUNC_QUALIFIER tvec4<T, P> operator*
(
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q
tvec4<T, P> const & v,
tquat<T, P> const & q
)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
GLM_FUNC_QUALIFIER tquat<T, P> operator*
(
detail::tquat<T, P> const & q,
tquat<T, P> const & q,
T const & s
)
{
return detail::tquat<T, P>(
return tquat<T, P>(
q.w * s, q.x * s, q.y * s, q.z * s);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
GLM_FUNC_QUALIFIER tquat<T, P> operator*
(
T const & s,
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return q * s;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> operator/
GLM_FUNC_QUALIFIER tquat<T, P> operator/
(
detail::tquat<T, P> const & q,
tquat<T, P> const & q,
T const & s
)
{
return detail::tquat<T, P>(
return tquat<T, P>(
q.w / s, q.x / s, q.y / s, q.z / s);
}
@ -377,8 +372,8 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator==
(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2
tquat<T, P> const & q1,
tquat<T, P> const & q2
)
{
return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
@ -387,46 +382,44 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator!=
(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2
tquat<T, P> const & q1,
tquat<T, P> const & q2
)
{
return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
}
}//namespace detail
////////////////////////////////////////////////////////
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return glm::sqrt(dot(q, q));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> normalize
GLM_FUNC_QUALIFIER tquat<T, P> normalize
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
T len = length(q);
if(len <= T(0)) // Problem
return detail::tquat<T, P>(1, 0, 0, 0);
return tquat<T, P>(1, 0, 0, 0);
T oneOverLen = T(1) / len;
return detail::tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
return tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> cross
GLM_FUNC_QUALIFIER tquat<T, P> cross
(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2
tquat<T, P> const & q1,
tquat<T, P> const & q2
)
{
return detail::tquat<T, P>(
return tquat<T, P>(
q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
@ -435,10 +428,10 @@ namespace detail
/*
// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> mix
GLM_FUNC_QUALIFIER tquat<T, P> mix
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
@ -446,7 +439,7 @@ namespace detail
if(a >= T(1)) return y;
float fCos = dot(x, y);
detail::tquat<T, P> y2(y); //BUG!!! tquat<T, P> y2;
tquat<T, P> y2(y); //BUG!!! tquat<T, P> y2;
if(fCos < T(0))
{
y2 = -y;
@ -469,7 +462,7 @@ namespace detail
k1 = sin((T(0) + a) * fAngle) * fOneOverSin;
}
return detail::tquat<T, P>(
return tquat<T, P>(
k0 * x.w + k1 * y2.w,
k0 * x.x + k1 * y2.x,
k0 * x.y + k1 * y2.y,
@ -477,10 +470,10 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> mix2
GLM_FUNC_QUALIFIER tquat<T, P> mix2
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
@ -515,10 +508,10 @@ namespace detail
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> mix
GLM_FUNC_QUALIFIER tquat<T, P> mix
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
@ -528,7 +521,7 @@ namespace detail
if(cosTheta > T(1) - epsilon<T>())
{
// Linear interpolation
return detail::tquat<T, P>(
return tquat<T, P>(
mix(x.w, y.w, a),
mix(x.x, y.x, a),
mix(x.y, y.y, a),
@ -543,10 +536,10 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> lerp
GLM_FUNC_QUALIFIER tquat<T, P> lerp
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
@ -558,14 +551,14 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> slerp
GLM_FUNC_QUALIFIER tquat<T, P> slerp
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
detail::tquat<T, P> z = y;
tquat<T, P> z = y;
T cosTheta = dot(x, y);
@ -581,7 +574,7 @@ namespace detail
if(cosTheta > T(1) - epsilon<T>())
{
// Linear interpolation
return detail::tquat<T, P>(
return tquat<T, P>(
mix(x.w, z.w, a),
mix(x.x, z.x, a),
mix(x.y, z.y, a),
@ -596,14 +589,14 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> rotate
GLM_FUNC_QUALIFIER tquat<T, P> rotate
(
detail::tquat<T, P> const & q,
tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tvec3<T, P> Tmp = v;
tvec3<T, P> Tmp = v;
// Axis of rotation must be normalised
T len = glm::length(Tmp);
@ -618,23 +611,23 @@ namespace detail
T const AngleRad(angle);
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);
//return gtc::quaternion::cross(q, detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
return q * tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> eulerAngles
GLM_FUNC_QUALIFIER tvec3<T, P> eulerAngles
(
detail::tquat<T, P> const & x
tquat<T, P> const & x
)
{
return detail::tvec3<T, P>(pitch(x), yaw(x), roll(x));
return tvec3<T, P>(pitch(x), yaw(x), roll(x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T roll
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
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));
@ -643,7 +636,7 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER T pitch
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
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));
@ -652,19 +645,19 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER T yaw
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return asin(T(-2) * (q.x * q.z - q.w * q.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> mat3_cast
GLM_FUNC_QUALIFIER tmat3x3<T, P> mat3_cast
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
detail::tmat3x3<T, P> Result(T(1));
tmat3x3<T, P> Result(T(1));
T qxx(q.x * q.x);
T qyy(q.y * q.y);
T qzz(q.z * q.z);
@ -690,18 +683,18 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> mat4_cast
GLM_FUNC_QUALIFIER tmat4x4<T, P> mat4_cast
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return detail::tmat4x4<T, P>(mat3_cast(q));
return tmat4x4<T, P>(mat3_cast(q));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> quat_cast
GLM_FUNC_QUALIFIER tquat<T, P> quat_cast
(
detail::tmat3x3<T, P> const & m
tmat3x3<T, P> const & m
)
{
T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
@ -730,7 +723,7 @@ namespace detail
T biggestVal = sqrt(fourBiggestSquaredMinus1 + T(1)) * T(0.5);
T mult = static_cast<T>(0.25) / biggestVal;
detail::tquat<T, P> Result;
tquat<T, P> Result;
switch(biggestIndex)
{
case 0:
@ -766,44 +759,44 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> quat_cast
GLM_FUNC_QUALIFIER tquat<T, P> quat_cast
(
detail::tmat4x4<T, P> const & m4
tmat4x4<T, P> const & m4
)
{
return quat_cast(detail::tmat3x3<T, P>(m4));
return quat_cast(tmat3x3<T, P>(m4));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T angle
(
detail::tquat<T, P> const & x
tquat<T, P> const & x
)
{
return acos(x.w) * T(2);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> axis
GLM_FUNC_QUALIFIER tvec3<T, P> axis
(
detail::tquat<T, P> const & x
tquat<T, P> const & x
)
{
T tmp1 = static_cast<T>(1) - x.w * x.w;
if(tmp1 <= static_cast<T>(0))
return detail::tvec3<T, P>(0, 0, 1);
return tvec3<T, P>(0, 0, 1);
T tmp2 = static_cast<T>(1) / sqrt(tmp1);
return detail::tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
return tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> angleAxis
GLM_FUNC_QUALIFIER tquat<T, P> angleAxis
(
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tquat<T, P> result;
tquat<T, P> result;
T const a(angle);
T const s = glm::sin(a * static_cast<T>(0.5));
@ -816,78 +809,78 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> lessThan
GLM_FUNC_QUALIFIER tvec4<bool, P> lessThan
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] < y[i];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> lessThanEqual
GLM_FUNC_QUALIFIER tvec4<bool, P> lessThanEqual
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] <= y[i];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> greaterThan
GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThan
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] > y[i];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> greaterThanEqual
GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThanEqual
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] >= y[i];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> equal
GLM_FUNC_QUALIFIER tvec4<bool, P> equal
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] == y[i];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> notEqual
GLM_FUNC_QUALIFIER tvec4<bool, P> notEqual
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y
tquat<T, P> const & x,
tquat<T, P> const & y
)
{
detail::tvec4<bool, P> Result;
tvec4<bool, P> Result;
for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] != y[i];
return Result;

8
glm/gtc/random.hpp
View file

@ -83,7 +83,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> circularRand(
GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
@ -91,7 +91,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> sphericalRand(
GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
T const & Radius);
/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
@ -99,7 +99,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> diskRand(
GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
@ -107,7 +107,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> ballRand(
GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
T const & Radius);
/// @}

60
glm/gtc/random.inl
View file

@ -42,32 +42,32 @@ namespace detail
};
template <precision P>
struct compute_rand<uint8, P, detail::tvec1>
struct compute_rand<uint8, P, tvec1>
{
GLM_FUNC_QUALIFIER static detail::tvec1<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec1<uint8, P> call()
{
return detail::tvec1<uint8, P>(
return tvec1<uint8, P>(
std::rand()) % std::numeric_limits<uint8>::max();
}
};
template <precision P>
struct compute_rand<uint8, P, detail::tvec2>
struct compute_rand<uint8, P, tvec2>
{
GLM_FUNC_QUALIFIER static detail::tvec2<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec2<uint8, P> call()
{
return detail::tvec2<uint8, P>(
return tvec2<uint8, P>(
std::rand(),
std::rand()) % std::numeric_limits<uint8>::max();
}
};
template <precision P>
struct compute_rand<uint8, P, detail::tvec3>
struct compute_rand<uint8, P, tvec3>
{
GLM_FUNC_QUALIFIER static detail::tvec3<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec3<uint8, P> call()
{
return detail::tvec3<uint8, P>(
return tvec3<uint8, P>(
std::rand(),
std::rand(),
std::rand()) % std::numeric_limits<uint8>::max();
@ -75,11 +75,11 @@ namespace detail
};
template <precision P>
struct compute_rand<uint8, P, detail::tvec4>
struct compute_rand<uint8, P, tvec4>
{
GLM_FUNC_QUALIFIER static detail::tvec4<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec4<uint8, P> call()
{
return detail::tvec4<uint8, P>(
return tvec4<uint8, P>(
std::rand(),
std::rand(),
std::rand(),
@ -297,9 +297,9 @@ namespace detail
float const & Max
)
{
return detail::compute_linearRand<float, highp, detail::tvec1>::call(
detail::tvec1<float, highp>(Min),
detail::tvec1<float, highp>(Max)).x;
return detail::compute_linearRand<float, highp, tvec1>::call(
tvec1<float, highp>(Min),
tvec1<float, highp>(Max)).x;
}
template <>
@ -309,9 +309,9 @@ namespace detail
double const & Max
)
{
return detail::compute_linearRand<double, highp, detail::tvec1>::call(
detail::tvec1<double, highp>(Min),
detail::tvec1<double, highp>(Max)).x;
return detail::compute_linearRand<double, highp, tvec1>::call(
tvec1<double, highp>(Min),
tvec1<double, highp>(Max)).x;
}
template <typename genType>
@ -337,19 +337,19 @@ namespace detail
VECTORIZE_VEC_VEC(gaussRand)
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> diskRand
GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand
(
T const & Radius
)
{
detail::tvec2<T, defaultp> Result(T(0));
tvec2<T, defaultp> Result(T(0));
T LenRadius(T(0));
do
{
Result = linearRand(
detail::tvec2<T, defaultp>(-Radius),
detail::tvec2<T, defaultp>(Radius));
tvec2<T, defaultp>(-Radius),
tvec2<T, defaultp>(Radius));
LenRadius = length(Result);
}
while(LenRadius > Radius);
@ -358,19 +358,19 @@ namespace detail
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> ballRand
GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand
(
T const & Radius
)
{
detail::tvec3<T, defaultp> Result(T(0));
tvec3<T, defaultp> Result(T(0));
T LenRadius(T(0));
do
{
Result = linearRand(
detail::tvec3<T, defaultp>(-Radius),
detail::tvec3<T, defaultp>(Radius));
tvec3<T, defaultp>(-Radius),
tvec3<T, defaultp>(Radius));
LenRadius = length(Result);
}
while(LenRadius > Radius);
@ -379,17 +379,17 @@ namespace detail
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> circularRand
GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand
(
T const & Radius
)
{
T a = linearRand(T(0), T(6.283185307179586476925286766559f));
return detail::tvec2<T, defaultp>(cos(a), sin(a)) * Radius;
return tvec2<T, defaultp>(cos(a), sin(a)) * Radius;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> sphericalRand
GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand
(
T const & Radius
)
@ -402,6 +402,6 @@ namespace detail
T x = r * cos(a);
T y = r * sin(a);
return detail::tvec3<T, defaultp>(x, y, z) * Radius;
return tvec3<T, defaultp>(x, y, z) * Radius;
}
}//namespace glm

164
glm/gtc/type_precision.hpp
View file

@ -272,70 +272,70 @@ namespace glm
/// 8 bit signed integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<i8, defaultp> i8vec1;
typedef tvec1<i8, defaultp> i8vec1;
/// 8 bit signed integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<i8, defaultp> i8vec2;
typedef tvec2<i8, defaultp> i8vec2;
/// 8 bit signed integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<i8, defaultp> i8vec3;
typedef tvec3<i8, defaultp> i8vec3;
/// 8 bit signed integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<i8, defaultp> i8vec4;
typedef tvec4<i8, defaultp> i8vec4;
/// 16 bit signed integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<i16, defaultp> i16vec1;
typedef tvec1<i16, defaultp> i16vec1;
/// 16 bit signed integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<i16, defaultp> i16vec2;
typedef tvec2<i16, defaultp> i16vec2;
/// 16 bit signed integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<i16, defaultp> i16vec3;
typedef tvec3<i16, defaultp> i16vec3;
/// 16 bit signed integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<i16, defaultp> i16vec4;
typedef tvec4<i16, defaultp> i16vec4;
/// 32 bit signed integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<i32, defaultp> i32vec1;
typedef tvec1<i32, defaultp> i32vec1;
/// 32 bit signed integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<i32, defaultp> i32vec2;
typedef tvec2<i32, defaultp> i32vec2;
/// 32 bit signed integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<i32, defaultp> i32vec3;
typedef tvec3<i32, defaultp> i32vec3;
/// 32 bit signed integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<i32, defaultp> i32vec4;
typedef tvec4<i32, defaultp> i32vec4;
/// 64 bit signed integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<i64, defaultp> i64vec1;
typedef tvec1<i64, defaultp> i64vec1;
/// 64 bit signed integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<i64, defaultp> i64vec2;
typedef tvec2<i64, defaultp> i64vec2;
/// 64 bit signed integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<i64, defaultp> i64vec3;
typedef tvec3<i64, defaultp> i64vec3;
/// 64 bit signed integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<i64, defaultp> i64vec4;
typedef tvec4<i64, defaultp> i64vec4;
/////////////////////////////
@ -544,70 +544,70 @@ namespace glm
/// Default precision 8 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<u8, defaultp> u8vec1;
typedef tvec1<u8, defaultp> u8vec1;
/// Default precision 8 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<u8, defaultp> u8vec2;
typedef tvec2<u8, defaultp> u8vec2;
/// Default precision 8 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<u8, defaultp> u8vec3;
typedef tvec3<u8, defaultp> u8vec3;
/// Default precision 8 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<u8, defaultp> u8vec4;
typedef tvec4<u8, defaultp> u8vec4;
/// Default precision 16 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<u16, defaultp> u16vec1;
typedef tvec1<u16, defaultp> u16vec1;
/// Default precision 16 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<u16, defaultp> u16vec2;
typedef tvec2<u16, defaultp> u16vec2;
/// Default precision 16 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<u16, defaultp> u16vec3;
typedef tvec3<u16, defaultp> u16vec3;
/// Default precision 16 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<u16, defaultp> u16vec4;
typedef tvec4<u16, defaultp> u16vec4;
/// Default precision 32 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<u32, defaultp> u32vec1;
typedef tvec1<u32, defaultp> u32vec1;
/// Default precision 32 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<u32, defaultp> u32vec2;
typedef tvec2<u32, defaultp> u32vec2;
/// Default precision 32 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<u32, defaultp> u32vec3;
typedef tvec3<u32, defaultp> u32vec3;
/// Default precision 32 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<u32, defaultp> u32vec4;
typedef tvec4<u32, defaultp> u32vec4;
/// Default precision 64 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef detail::tvec1<u64, defaultp> u64vec1;
typedef tvec1<u64, defaultp> u64vec1;
/// Default precision 64 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef detail::tvec2<u64, defaultp> u64vec2;
typedef tvec2<u64, defaultp> u64vec2;
/// Default precision 64 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef detail::tvec3<u64, defaultp> u64vec3;
typedef tvec3<u64, defaultp> u64vec3;
/// Default precision 64 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef detail::tvec4<u64, defaultp> u64vec4;
typedef tvec4<u64, defaultp> u64vec4;
//////////////////////
@ -642,53 +642,53 @@ namespace glm
/// Single-precision floating-point vector of 1 component.
/// @see gtc_type_precision
typedef detail::tvec1<float, defaultp> fvec1;
typedef tvec1<float, defaultp> fvec1;
/// Single-precision floating-point vector of 2 components.
/// @see gtc_type_precision
typedef detail::tvec2<float, defaultp> fvec2;
typedef tvec2<float, defaultp> fvec2;
/// Single-precision floating-point vector of 3 components.
/// @see gtc_type_precision
typedef detail::tvec3<float, defaultp> fvec3;
typedef tvec3<float, defaultp> fvec3;
/// Single-precision floating-point vector of 4 components.
/// @see gtc_type_precision
typedef detail::tvec4<float, defaultp> fvec4;
typedef tvec4<float, defaultp> fvec4;
/// Single-precision floating-point vector of 1 component.
/// @see gtc_type_precision
typedef detail::tvec1<f32, defaultp> f32vec1;
typedef tvec1<f32, defaultp> f32vec1;
/// Single-precision floating-point vector of 2 components.
/// @see gtc_type_precision
typedef detail::tvec2<f32, defaultp> f32vec2;
typedef tvec2<f32, defaultp> f32vec2;
/// Single-precision floating-point vector of 3 components.
/// @see gtc_type_precision
typedef detail::tvec3<f32, defaultp> f32vec3;
typedef tvec3<f32, defaultp> f32vec3;
/// Single-precision floating-point vector of 4 components.
/// @see gtc_type_precision
typedef detail::tvec4<f32, defaultp> f32vec4;
typedef tvec4<f32, defaultp> f32vec4;
/// Double-precision floating-point vector of 1 component.
/// @see gtc_type_precision
typedef detail::tvec1<f64, defaultp> f64vec1;
typedef tvec1<f64, defaultp> f64vec1;
/// Double-precision floating-point vector of 2 components.
/// @see gtc_type_precision
typedef detail::tvec2<f64, defaultp> f64vec2;
typedef tvec2<f64, defaultp> f64vec2;
/// Double-precision floating-point vector of 3 components.
/// @see gtc_type_precision
typedef detail::tvec3<f64, defaultp> f64vec3;
typedef tvec3<f64, defaultp> f64vec3;
/// Double-precision floating-point vector of 4 components.
/// @see gtc_type_precision
typedef detail::tvec4<f64, defaultp> f64vec4;
typedef tvec4<f64, defaultp> f64vec4;
//////////////////////
@ -700,15 +700,15 @@ namespace glm
/// Single-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f32, defaultp> fmat2;
typedef tmat2x2<f32, defaultp> fmat2;
/// Single-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f32, defaultp> fmat3;
typedef tmat3x3<f32, defaultp> fmat3;
/// Single-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f32, defaultp> fmat4;
typedef tmat4x4<f32, defaultp> fmat4;
/// Single-precision floating-point 1x1 matrix.
@ -717,39 +717,39 @@ namespace glm
/// Single-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f32, defaultp> fmat2x2;
typedef tmat2x2<f32, defaultp> fmat2x2;
/// Single-precision floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x3<f32, defaultp> fmat2x3;
typedef tmat2x3<f32, defaultp> fmat2x3;
/// Single-precision floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x4<f32, defaultp> fmat2x4;
typedef tmat2x4<f32, defaultp> fmat2x4;
/// Single-precision floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x2<f32, defaultp> fmat3x2;
typedef tmat3x2<f32, defaultp> fmat3x2;
/// Single-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f32, defaultp> fmat3x3;
typedef tmat3x3<f32, defaultp> fmat3x3;
/// Single-precision floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x4<f32, defaultp> fmat3x4;
typedef tmat3x4<f32, defaultp> fmat3x4;
/// Single-precision floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x2<f32, defaultp> fmat4x2;
typedef tmat4x2<f32, defaultp> fmat4x2;
/// Single-precision floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x3<f32, defaultp> fmat4x3;
typedef tmat4x3<f32, defaultp> fmat4x3;
/// Single-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f32, defaultp> fmat4x4;
typedef tmat4x4<f32, defaultp> fmat4x4;
/// Single-precision floating-point 1x1 matrix.
@ -758,15 +758,15 @@ namespace glm
/// Single-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f32, defaultp> f32mat2;
typedef tmat2x2<f32, defaultp> f32mat2;
/// Single-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f32, defaultp> f32mat3;
typedef tmat3x3<f32, defaultp> f32mat3;
/// Single-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f32, defaultp> f32mat4;
typedef tmat4x4<f32, defaultp> f32mat4;
/// Single-precision floating-point 1x1 matrix.
@ -775,39 +775,39 @@ namespace glm
/// Single-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f32, defaultp> f32mat2x2;
typedef tmat2x2<f32, defaultp> f32mat2x2;
/// Single-precision floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x3<f32, defaultp> f32mat2x3;
typedef tmat2x3<f32, defaultp> f32mat2x3;
/// Single-precision floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x4<f32, defaultp> f32mat2x4;
typedef tmat2x4<f32, defaultp> f32mat2x4;
/// Single-precision floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x2<f32, defaultp> f32mat3x2;
typedef tmat3x2<f32, defaultp> f32mat3x2;
/// Single-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f32, defaultp> f32mat3x3;
typedef tmat3x3<f32, defaultp> f32mat3x3;
/// Single-precision floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x4<f32, defaultp> f32mat3x4;
typedef tmat3x4<f32, defaultp> f32mat3x4;
/// Single-precision floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x2<f32, defaultp> f32mat4x2;
typedef tmat4x2<f32, defaultp> f32mat4x2;
/// Single-precision floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x3<f32, defaultp> f32mat4x3;
typedef tmat4x3<f32, defaultp> f32mat4x3;
/// Single-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f32, defaultp> f32mat4x4;
typedef tmat4x4<f32, defaultp> f32mat4x4;
/// Double-precision floating-point 1x1 matrix.
@ -816,15 +816,15 @@ namespace glm
/// Double-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f64, defaultp> f64mat2;
typedef tmat2x2<f64, defaultp> f64mat2;
/// Double-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f64, defaultp> f64mat3;
typedef tmat3x3<f64, defaultp> f64mat3;
/// Double-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f64, defaultp> f64mat4;
typedef tmat4x4<f64, defaultp> f64mat4;
/// Double-precision floating-point 1x1 matrix.
@ -833,39 +833,39 @@ namespace glm
/// Double-precision floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x2<f64, defaultp> f64mat2x2;
typedef tmat2x2<f64, defaultp> f64mat2x2;
/// Double-precision floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x3<f64, defaultp> f64mat2x3;
typedef tmat2x3<f64, defaultp> f64mat2x3;
/// Double-precision floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat2x4<f64, defaultp> f64mat2x4;
typedef tmat2x4<f64, defaultp> f64mat2x4;
/// Double-precision floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x2<f64, defaultp> f64mat3x2;
typedef tmat3x2<f64, defaultp> f64mat3x2;
/// Double-precision floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x3<f64, defaultp> f64mat3x3;
typedef tmat3x3<f64, defaultp> f64mat3x3;
/// Double-precision floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat3x4<f64, defaultp> f64mat3x4;
typedef tmat3x4<f64, defaultp> f64mat3x4;
/// Double-precision floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x2<f64, defaultp> f64mat4x2;
typedef tmat4x2<f64, defaultp> f64mat4x2;
/// Double-precision floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x3<f64, defaultp> f64mat4x3;
typedef tmat4x3<f64, defaultp> f64mat4x3;
/// Double-precision floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef detail::tmat4x4<f64, defaultp> f64mat4x4;
typedef tmat4x4<f64, defaultp> f64mat4x4;
//////////////////////////
@ -873,11 +873,11 @@ namespace glm
/// Single-precision floating-point quaternion.
/// @see gtc_type_precision
typedef detail::tquat<f32, defaultp> f32quat;
typedef tquat<f32, defaultp> f32quat;
/// Double-precision floating-point quaternion.
/// @see gtc_type_precision
typedef detail::tquat<f64, defaultp> f64quat;
typedef tquat<f64, defaultp> f64quat;
/// @}
}//namespace glm

32
glm/gtc/type_ptr.hpp
View file

@ -91,83 +91,83 @@ namespace glm
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> make_vec2(T const * const ptr);
GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr);
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> make_vec3(T const * const ptr);
GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr);
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec4<T, defaultp> make_vec4(T const * const ptr);
GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x2<T, defaultp> make_mat4x2(
GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(
T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr);
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr);
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr);
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr);
/// Build a quaternion from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tquat<T, defaultp> make_quat(T const * const ptr);
GLM_FUNC_DECL tquat<T, defaultp> make_quat(T const * const ptr);
/// @}
}//namespace glm

136
glm/gtc/type_ptr.inl
View file

@ -38,7 +38,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec2<T, P> const & vec
tvec2<T, P> const & vec
)
{
return &(vec.x);
@ -49,7 +49,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec2<T, P> & vec
tvec2<T, P> & vec
)
{
return &(vec.x);
@ -60,7 +60,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec3<T, P> const & vec
tvec3<T, P> const & vec
)
{
return &(vec.x);
@ -71,7 +71,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec3<T, P> & vec
tvec3<T, P> & vec
)
{
return &(vec.x);
@ -82,7 +82,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec4<T, P> const & vec
tvec4<T, P> const & vec
)
{
return &(vec.x);
@ -93,7 +93,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec4<T, P> & vec
tvec4<T, P> & vec
)
{
return &(vec.x);
@ -104,7 +104,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x2<T, P> const & mat
tmat2x2<T, P> const & mat
)
{
return &(mat[0].x);
@ -115,7 +115,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x2<T, P> & mat
tmat2x2<T, P> & mat
)
{
return &(mat[0].x);
@ -126,7 +126,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x3<T, P> const & mat
tmat3x3<T, P> const & mat
)
{
return &(mat[0].x);
@ -137,7 +137,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x3<T, P> & mat
tmat3x3<T, P> & mat
)
{
return &(mat[0].x);
@ -148,7 +148,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x4<T, P> const & mat
tmat4x4<T, P> const & mat
)
{
return &(mat[0].x);
@ -159,7 +159,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x4<T, P> & mat
tmat4x4<T, P> & mat
)
{
return &(mat[0].x);
@ -170,7 +170,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x3<T, P> const & mat
tmat2x3<T, P> const & mat
)
{
return &(mat[0].x);
@ -181,7 +181,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x3<T, P> & mat
tmat2x3<T, P> & mat
)
{
return &(mat[0].x);
@ -192,7 +192,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x2<T, P> const & mat
tmat3x2<T, P> const & mat
)
{
return &(mat[0].x);
@ -203,7 +203,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x2<T, P> & mat
tmat3x2<T, P> & mat
)
{
return &(mat[0].x);
@ -214,7 +214,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x4<T, P> const & mat
tmat2x4<T, P> const & mat
)
{
return &(mat[0].x);
@ -225,7 +225,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x4<T, P> & mat
tmat2x4<T, P> & mat
)
{
return &(mat[0].x);
@ -236,7 +236,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x2<T, P> const & mat
tmat4x2<T, P> const & mat
)
{
return &(mat[0].x);
@ -247,7 +247,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x2<T, P> & mat
tmat4x2<T, P> & mat
)
{
return &(mat[0].x);
@ -258,7 +258,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x4<T, P> const & mat
tmat3x4<T, P> const & mat
)
{
return &(mat[0].x);
@ -269,7 +269,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x4<T, P> & mat
tmat3x4<T, P> & mat
)
{
return &(mat[0].x);
@ -280,7 +280,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x3<T, P> const & mat
tmat4x3<T, P> const & mat
)
{
return &(mat[0].x);
@ -289,7 +289,7 @@ namespace glm
/// Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T, P> & mat)
GLM_FUNC_QUALIFIER T * value_ptr(tmat4x3<T, P> & mat)
{
return &(mat[0].x);
}
@ -299,7 +299,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return &(q[0]);
@ -310,7 +310,7 @@ namespace glm
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tquat<T, P> & q
tquat<T, P> & q
)
{
return &(q[0]);
@ -319,127 +319,127 @@ namespace glm
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> make_vec2(T const * const ptr)
GLM_FUNC_QUALIFIER tvec2<T, defaultp> make_vec2(T const * const ptr)
{
detail::tvec2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T, defaultp>));
tvec2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec2<T, defaultp>));
return Result;
}
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> make_vec3(T const * const ptr)
GLM_FUNC_QUALIFIER tvec3<T, defaultp> make_vec3(T const * const ptr)
{
detail::tvec3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T, defaultp>));
tvec3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec3<T, defaultp>));
return Result;
}
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> make_vec4(T const * const ptr)
GLM_FUNC_QUALIFIER tvec4<T, defaultp> make_vec4(T const * const ptr)
{
detail::tvec4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T, defaultp>));
tvec4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec4<T, defaultp>));
return Result;
}
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
{
detail::tmat2x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T, defaultp>));
tmat2x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x2<T, defaultp>));
return Result;
}
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
{
detail::tmat2x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T, defaultp>));
tmat2x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x3<T, defaultp>));
return Result;
}
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
{
detail::tmat2x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T, defaultp>));
tmat2x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x4<T, defaultp>));
return Result;
}
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
{
detail::tmat3x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T, defaultp>));
tmat3x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x2<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
{
detail::tmat3x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T, defaultp>));
tmat3x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x3<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
{
detail::tmat3x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T, defaultp>));
tmat3x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x4<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
{
detail::tmat4x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T, defaultp>));
tmat4x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x2<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
{
detail::tmat4x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T, defaultp>));
tmat4x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x3<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
{
detail::tmat4x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T, defaultp>));
tmat4x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x4<T, defaultp>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2(T const * const ptr)
{
return make_mat2x2(ptr);
}
@ -447,7 +447,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3(T const * const ptr)
{
return make_mat3x3(ptr);
}
@ -455,7 +455,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4(T const * const ptr)
{
return make_mat4x4(ptr);
}
@ -463,10 +463,10 @@ namespace glm
//! Build a quaternion from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER detail::tquat<T, defaultp> make_quat(T const * const ptr)
GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const * const ptr)
{
detail::tquat<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T, defaultp>));
tquat<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tquat<T, defaultp>));
return Result;
}

576
glm/gtx/associated_min_max.inl
View file

File diff suppressed because it is too large Load diff

72
glm/gtx/bit.inl
View file

@ -41,35 +41,35 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<int, P> highestBitValue
GLM_FUNC_QUALIFIER tvec2<int, P> highestBitValue
(
detail::tvec2<T, P> const & value
tvec2<T, P> const & value
)
{
return detail::tvec2<int, P>(
return tvec2<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<int, P> highestBitValue
GLM_FUNC_QUALIFIER tvec3<int, P> highestBitValue
(
detail::tvec3<T, P> const & value
tvec3<T, P> const & value
)
{
return detail::tvec3<int, P>(
return tvec3<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<int, P> highestBitValue
GLM_FUNC_QUALIFIER tvec4<int, P> highestBitValue
(
detail::tvec4<T, P> const & value
tvec4<T, P> const & value
)
{
return detail::tvec4<int, P>(
return tvec4<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]),
@ -91,35 +91,35 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isPowerOfTwo
GLM_FUNC_QUALIFIER tvec2<bool, P> isPowerOfTwo
(
detail::tvec2<T, P> const & value
tvec2<T, P> const & value
)
{
return detail::tvec2<bool, P>(
return tvec2<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isPowerOfTwo
GLM_FUNC_QUALIFIER tvec3<bool, P> isPowerOfTwo
(
detail::tvec3<T, P> const & value
tvec3<T, P> const & value
)
{
return detail::tvec3<bool, P>(
return tvec3<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isPowerOfTwo
GLM_FUNC_QUALIFIER tvec4<bool, P> isPowerOfTwo
(
detail::tvec4<T, P> const & value
tvec4<T, P> const & value
)
{
return detail::tvec4<bool, P>(
return tvec4<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]),
@ -189,38 +189,38 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateRight
GLM_FUNC_QUALIFIER tvec2<T, P> bitRotateRight
(
detail::tvec2<T, P> const & Value,
tvec2<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateRight
GLM_FUNC_QUALIFIER tvec3<T, P> bitRotateRight
(
detail::tvec3<T, P> const & Value,
tvec3<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateRight
GLM_FUNC_QUALIFIER tvec4<T, P> bitRotateRight
(
detail::tvec4<T, P> const & Value,
tvec4<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift),
@ -237,38 +237,38 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateLeft
GLM_FUNC_QUALIFIER tvec2<T, P> bitRotateLeft
(
detail::tvec2<T, P> const & Value,
tvec2<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateLeft
GLM_FUNC_QUALIFIER tvec3<T, P> bitRotateLeft
(
detail::tvec3<T, P> const & Value,
tvec3<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateLeft
GLM_FUNC_QUALIFIER tvec4<T, P> bitRotateLeft
(
detail::tvec4<T, P> const & Value,
tvec4<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift),

16
glm/gtx/closest_point.hpp
View file

@ -52,17 +52,17 @@ namespace glm
/// Find the point on a straight line which is the closet of a point.
/// @see gtx_closest_point
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> closestPointOnLine(
detail::tvec3<T, P> const & point,
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b);
GLM_FUNC_DECL tvec3<T, P> closestPointOnLine(
tvec3<T, P> const & point,
tvec3<T, P> const & a,
tvec3<T, P> const & b);
/// 2d lines work as well
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec2<T, P> closestPointOnLine(
detail::tvec2<T, P> const & point,
detail::tvec2<T, P> const & a,
detail::tvec2<T, P> const & b);
GLM_FUNC_DECL tvec2<T, P> closestPointOnLine(
tvec2<T, P> const & point,
tvec2<T, P> const & a,
tvec2<T, P> const & b);
/// @}
}// namespace glm

24
glm/gtx/closest_point.inl
View file

@ -10,16 +10,16 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> closestPointOnLine
GLM_FUNC_QUALIFIER tvec3<T, P> closestPointOnLine
(
detail::tvec3<T, P> const & point,
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b
tvec3<T, P> const & point,
tvec3<T, P> const & a,
tvec3<T, P> const & b
)
{
T LineLength = distance(a, b);
detail::tvec3<T, P> Vector = point - a;
detail::tvec3<T, P> LineDirection = (b - a) / LineLength;
tvec3<T, P> Vector = point - a;
tvec3<T, P> LineDirection = (b - a) / LineLength;
// Project Vector to LineDirection to get the distance of point from a
T Distance = dot(Vector, LineDirection);
@ -30,16 +30,16 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> closestPointOnLine
GLM_FUNC_QUALIFIER tvec2<T, P> closestPointOnLine
(
detail::tvec2<T, P> const & point,
detail::tvec2<T, P> const & a,
detail::tvec2<T, P> const & b
tvec2<T, P> const & point,
tvec2<T, P> const & a,
tvec2<T, P> const & b
)
{
T LineLength = distance(a, b);
detail::tvec2<T, P> Vector = point - a;
detail::tvec2<T, P> LineDirection = (b - a) / LineLength;
tvec2<T, P> Vector = point - a;
tvec2<T, P> LineDirection = (b - a) / LineLength;
// Project Vector to LineDirection to get the distance of point from a
T Distance = dot(Vector, LineDirection);

20
glm/gtx/color_space.hpp
View file

@ -52,40 +52,40 @@ namespace glm
/// Converts a color from HSV color space to its color in RGB color space.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgbColor(
detail::tvec3<T, P> const & hsvValue);
GLM_FUNC_DECL tvec3<T, P> rgbColor(
tvec3<T, P> const & hsvValue);
/// Converts a color from RGB color space to its color in HSV color space.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> hsvColor(
detail::tvec3<T, P> const & rgbValue);
GLM_FUNC_DECL tvec3<T, P> hsvColor(
tvec3<T, P> const & rgbValue);
/// Build a saturation matrix.
/// @see gtx_color_space
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> saturation(
GLM_FUNC_DECL tmat4x4<T, defaultp> saturation(
T const s);
/// Modify the saturation of a color.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> saturation(
GLM_FUNC_DECL tvec3<T, P> saturation(
T const s,
detail::tvec3<T, P> const & color);
tvec3<T, P> const & color);
/// Modify the saturation of a color.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> saturation(
GLM_FUNC_DECL tvec4<T, P> saturation(
T const s,
detail::tvec4<T, P> const & color);
tvec4<T, P> const & color);
/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL T luminosity(
detail::tvec3<T, P> const & color);
tvec3<T, P> const & color);
/// @}
}//namespace glm

28
glm/gtx/color_space.inl
View file

@ -10,14 +10,14 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgbColor(const detail::tvec3<T, P>& hsvColor)
GLM_FUNC_QUALIFIER tvec3<T, P> rgbColor(const tvec3<T, P>& hsvColor)
{
detail::tvec3<T, P> hsv = hsvColor;
detail::tvec3<T, P> rgbColor;
tvec3<T, P> hsv = hsvColor;
tvec3<T, P> rgbColor;
if(hsv.y == static_cast<T>(0))
// achromatic (grey)
rgbColor = detail::tvec3<T, P>(hsv.z);
rgbColor = tvec3<T, P>(hsv.z);
else
{
T sector = floor(hsv.x / T(60));
@ -67,9 +67,9 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> hsvColor(const detail::tvec3<T, P>& rgbColor)
GLM_FUNC_QUALIFIER tvec3<T, P> hsvColor(const tvec3<T, P>& rgbColor)
{
detail::tvec3<T, P> hsv = rgbColor;
tvec3<T, P> hsv = rgbColor;
float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
float Delta = Max - Min;
@ -107,15 +107,15 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> saturation(T const s)
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> saturation(T const s)
{
detail::tvec3<T, defaultp> rgbw = detail::tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
tvec3<T, defaultp> rgbw = tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
T col0 = (T(1) - s) * rgbw.r;
T col1 = (T(1) - s) * rgbw.g;
T col2 = (T(1) - s) * rgbw.b;
detail::tmat4x4<T, defaultp> result(T(1));
tmat4x4<T, defaultp> result(T(1));
result[0][0] = col0 + s;
result[0][1] = col0;
result[0][2] = col0;
@ -129,21 +129,21 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturation(const T s, const detail::tvec3<T, P>& color)
GLM_FUNC_QUALIFIER tvec3<T, P> saturation(const T s, const tvec3<T, P>& color)
{
return detail::tvec3<T, P>(saturation(s) * detail::tvec4<T, P>(color, T(0)));
return tvec3<T, P>(saturation(s) * tvec4<T, P>(color, T(0)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturation(const T s, const detail::tvec4<T, P>& color)
GLM_FUNC_QUALIFIER tvec4<T, P> saturation(const T s, const tvec4<T, P>& color)
{
return saturation(s) * color;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T, P>& color)
GLM_FUNC_QUALIFIER T luminosity(const tvec3<T, P>& color)
{
const detail::tvec3<T, P> tmp = detail::tvec3<T, P>(0.33, 0.59, 0.11);
const tvec3<T, P> tmp = tvec3<T, P>(0.33, 0.59, 0.11);
return dot(color, tmp);
}
}//namespace glm

16
glm/gtx/color_space_YCoCg.hpp
View file

@ -52,28 +52,28 @@ namespace glm
/// Convert a color from RGB color space to YCoCg color space.
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCg(
detail::tvec3<T, P> const & rgbColor);
GLM_FUNC_DECL tvec3<T, P> rgb2YCoCg(
tvec3<T, P> const & rgbColor);
/// Convert a color from YCoCg color space to RGB color space.
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> YCoCg2rgb(
detail::tvec3<T, P> const & YCoCgColor);
GLM_FUNC_DECL tvec3<T, P> YCoCg2rgb(
tvec3<T, P> const & YCoCgColor);
/// Convert a color from RGB color space to YCoCgR color space.
/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCgR(
detail::tvec3<T, P> const & rgbColor);
GLM_FUNC_DECL tvec3<T, P> rgb2YCoCgR(
tvec3<T, P> const & rgbColor);
/// Convert a color from YCoCgR color space to RGB color space.
/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> YCoCgR2rgb(
detail::tvec3<T, P> const & YCoCgColor);
GLM_FUNC_DECL tvec3<T, P> YCoCgR2rgb(
tvec3<T, P> const & YCoCgColor);
/// @}
}//namespace glm

24
glm/gtx/color_space_YCoCg.inl
View file

@ -10,12 +10,12 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCg
GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCg
(
detail::tvec3<T, P> const & rgbColor
tvec3<T, P> const & rgbColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.x/*Y */ = rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
result.y/*Co*/ = rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
@ -23,12 +23,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCgR
GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
(
detail::tvec3<T, P> const & rgbColor
tvec3<T, P> const & rgbColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.x/*Y */ = rgbColor.g / T(2) + (rgbColor.r + rgbColor.b) / T(4);
result.y/*Co*/ = rgbColor.r - rgbColor.b;
result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / T(2);
@ -36,12 +36,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCg2rgb
GLM_FUNC_QUALIFIER tvec3<T, P> YCoCg2rgb
(
detail::tvec3<T, P> const & YCoCgColor
tvec3<T, P> const & YCoCgColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
result.g = YCoCgColor.x + YCoCgColor.z;
result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
@ -49,12 +49,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCgR2rgb
GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
(
detail::tvec3<T, P> const & YCoCgRColor
tvec3<T, P> const & YCoCgRColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
T tmp = YCoCgRColor.x - (YCoCgRColor.z / T(2));
result.g = YCoCgRColor.z + tmp;
result.b = tmp - (YCoCgRColor.y / T(2));

24
glm/gtx/common.inl
View file

@ -43,53 +43,53 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isdenormal
GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isdenormal
(
detail::tvec1<T, P> const & x
tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename detail::tvec1<T, P>::bool_type(
return typename tvec1<T, P>::bool_type(
isdenormal(x.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isdenormal
GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isdenormal
(
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename detail::tvec2<T, P>::bool_type(
return typename tvec2<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isdenormal
GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isdenormal
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename detail::tvec3<T, P>::bool_type(
return typename tvec3<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y),
isdenormal(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isdenormal
GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isdenormal
(
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename detail::tvec4<T, P>::bool_type(
return typename tvec4<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y),
isdenormal(x.z),

128
glm/gtx/compatibility.hpp
View file

@ -61,94 +61,94 @@ namespace glm
/// @{
template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, const detail::tvec2<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, const detail::tvec3<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, const detail::tvec4<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, const tvec2<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, const tvec3<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, const tvec4<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> saturate(const tvec2<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> saturate(const tvec3<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> saturate(const tvec4<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> atan2(const tvec2<T, P>& x, const tvec2<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> atan2(const tvec3<T, P>& x, const tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> atan2(const tvec4<T, P>& x, const tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec2<bool, P> isfinite(const tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec3<bool, P> isfinite(const tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec4<bool, P> isfinite(const tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef float float1; //!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<float, highp> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<float, highp> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<float, highp> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<float, highp> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<float, highp> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<float, highp> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef float float1x1; //!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<float, highp> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<float, highp> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<float, highp> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<float, highp> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<float, highp> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<float, highp> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<float, highp> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<float, highp> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<float, highp> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<float, highp> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<float, highp> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<float, highp> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<float, highp> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<float, highp> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<float, highp> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<float, highp> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<float, highp> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<float, highp> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef double double1; //!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<double, highp> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<double, highp> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<double, highp> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<double, highp> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<double, highp> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<double, highp> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef double double1x1; //!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<double, highp> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<double, highp> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<double, highp> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<double, highp> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<double, highp> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<double, highp> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<double, highp> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<double, highp> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<double, highp> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<double, highp> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<double, highp> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<double, highp> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<double, highp> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<double, highp> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<double, highp> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<double, highp> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<double, highp> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<double, highp> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
/// @}
}//namespace glm

18
glm/gtx/compatibility.inl
View file

@ -28,29 +28,29 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isfinite(
detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<bool, P> isfinite(
tvec2<T, P> const & x)
{
return detail::tvec2<bool, P>(
return tvec2<bool, P>(
isfinite(x.x),
isfinite(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isfinite(
detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<bool, P> isfinite(
tvec3<T, P> const & x)
{
return detail::tvec3<bool, P>(
return tvec3<bool, P>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isfinite(
detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<bool, P> isfinite(
tvec4<T, P> const & x)
{
return detail::tvec4<bool, P>(
return tvec4<bool, P>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z),

118
glm/gtx/dual_quaternion.hpp
View file

@ -49,18 +49,20 @@
# pragma message("GLM: GLM_GTX_dual_quaternion extension included")
#endif
namespace glm{
namespace detail
namespace glm
{
/// @addtogroup gtc_dual_quaternion
/// @{
template <typename T, precision P>
struct tdualquat
{
enum ctor{null};
typedef T value_type;
typedef glm::detail::tquat<T, P> part_type;
typedef glm::tquat<T, P> part_type;
public:
glm::detail::tquat<T, P> real, dual;
glm::tquat<T, P> real, dual;
GLM_FUNC_DECL GLM_CONSTEXPR length_t length() const;
@ -85,80 +87,76 @@ namespace detail
};
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator- (
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> operator- (
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator+ (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
GLM_FUNC_DECL tdualquat<T, P> operator+ (
tdualquat<T, P> const & q,
tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
GLM_FUNC_DECL tdualquat<T, P> operator* (
tdualquat<T, P> const & q,
tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> operator* (
tquat<T, P> const & q,
tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec3<T, P> operator* (
tvec3<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tvec4<T, P> operator* (
tquat<T, P> const & q,
tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec4<T, P> operator* (
tvec4<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
GLM_FUNC_DECL tdualquat<T, P> operator* (
tdualquat<T, P> const & q,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
GLM_FUNC_DECL tdualquat<T, P> operator* (
T const & s,
detail::tdualquat<T, P> const & q);
tdualquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator/ (
detail::tdualquat<T, P> const & q,
GLM_FUNC_DECL tdualquat<T, P> operator/ (
tdualquat<T, P> const & q,
T const & s);
} //namespace detail
/// @addtogroup gtc_dual_quaternion
/// @{
/// Returns the normalized quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> normalize(
detail::tdualquat<T, P> const & q);
GLM_FUNC_DECL tdualquat<T, P> normalize(
tdualquat<T, P> const & q);
/// Returns the linear interpolation of two dual quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> lerp(
detail::tdualquat<T, P> const & x,
detail::tdualquat<T, P> const & y,
GLM_FUNC_DECL tdualquat<T, P> lerp(
tdualquat<T, P> const & x,
tdualquat<T, P> const & y,
T const & a);
/// Returns the q inverse.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> inverse(
detail::tdualquat<T, P> const & q);
GLM_FUNC_DECL tdualquat<T, P> inverse(
tdualquat<T, P> const & q);
/*
/// Extracts a rotation part from dual-quaternion to a 3 * 3 matrix.
@ -166,85 +164,85 @@ namespace detail
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
detail::tmat3x3<T, P> mat3_cast(
detail::tdualquat<T, P> const & x);
tmat3x3<T, P> mat3_cast(
tdualquat<T, P> const & x);
*/
/// Converts a quaternion to a 2 * 4 matrix.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x4<T, P> mat2x4_cast(
detail::tdualquat<T, P> const & x);
GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(
tdualquat<T, P> const & x);
/// Converts a quaternion to a 3 * 4 matrix.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x4<T, P> mat3x4_cast(
detail::tdualquat<T, P> const & x);
GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(
tdualquat<T, P> const & x);
/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tmat2x4<T, P> const & x);
GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
tmat2x4<T, P> const & x);
/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tmat3x4<T, P> const & x);
GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
tmat3x4<T, P> const & x);
/// Dual-quaternion of low single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, lowp> lowp_dualquat;
typedef tdualquat<float, lowp> lowp_dualquat;
/// Dual-quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, mediump> mediump_dualquat;
typedef tdualquat<float, mediump> mediump_dualquat;
/// Dual-quaternion of high single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, highp> highp_dualquat;
typedef tdualquat<float, highp> highp_dualquat;
/// Dual-quaternion of low single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, lowp> lowp_fdualquat;
typedef tdualquat<float, lowp> lowp_fdualquat;
/// Dual-quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, mediump> mediump_fdualquat;
typedef tdualquat<float, mediump> mediump_fdualquat;
/// Dual-quaternion of high single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, highp> highp_fdualquat;
typedef tdualquat<float, highp> highp_fdualquat;
/// Dual-quaternion of low double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, lowp> lowp_ddualquat;
typedef tdualquat<double, lowp> lowp_ddualquat;
/// Dual-quaternion of medium double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, mediump> mediump_ddualquat;
typedef tdualquat<double, mediump> mediump_ddualquat;
/// Dual-quaternion of high double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, highp> highp_ddualquat;
typedef tdualquat<double, highp> highp_ddualquat;
#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))

144
glm/gtx/dual_quaternion.inl
View file

@ -29,8 +29,7 @@
#include "../geometric.hpp"
#include <limits>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tdualquat<T, P>::length() const
@ -143,105 +142,105 @@ namespace detail
// tquat<valType> external operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator-
GLM_FUNC_QUALIFIER tdualquat<T, P> operator-
(
detail::tdualquat<T, P> const & q
tdualquat<T, P> const & q
)
{
return detail::tdualquat<T, P>(-q.real,-q.dual);
return tdualquat<T, P>(-q.real,-q.dual);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator+
GLM_FUNC_QUALIFIER tdualquat<T, P> operator+
(
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p
tdualquat<T, P> const & q,
tdualquat<T, P> const & p
)
{
return detail::tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
return tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
(
detail::tdualquat<T, P> const & p,
detail::tdualquat<T, P> const & o
tdualquat<T, P> const & p,
tdualquat<T, P> const & o
)
{
return detail::tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
return tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
}
// Transformation
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
GLM_FUNC_QUALIFIER tvec3<T, P> operator*
(
detail::tdualquat<T, P> const & q,
detail::tvec3<T, P> const & v
tdualquat<T, P> const & q,
tvec3<T, P> const & v
)
{
detail::tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
detail::tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
GLM_FUNC_QUALIFIER tvec3<T, P> operator*
(
detail::tvec3<T, P> const & v,
detail::tdualquat<T, P> const & q
tvec3<T, P> const & v,
tdualquat<T, P> const & q
)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
GLM_FUNC_QUALIFIER tvec4<T, P> operator*
(
detail::tdualquat<T, P> const & q,
detail::tvec4<T, P> const & v
tdualquat<T, P> const & q,
tvec4<T, P> const & v
)
{
return detail::tvec4<T, P>(q * detail::tvec3<T, P>(v), v.w);
return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
GLM_FUNC_QUALIFIER tvec4<T, P> operator*
(
detail::tvec4<T, P> const & v,
detail::tdualquat<T, P> const & q
tvec4<T, P> const & v,
tdualquat<T, P> const & q
)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
(
detail::tdualquat<T, P> const & q,
tdualquat<T, P> const & q,
T const & s
)
{
return detail::tdualquat<T, P>(q.real * s, q.dual * s);
return tdualquat<T, P>(q.real * s, q.dual * s);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
(
T const & s,
detail::tdualquat<T, P> const & q
tdualquat<T, P> const & q
)
{
return q * s;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator/
GLM_FUNC_QUALIFIER tdualquat<T, P> operator/
(
detail::tdualquat<T, P> const & q,
tdualquat<T, P> const & q,
T const & s
)
{
return detail::tdualquat<T, P>(q.real / s, q.dual / s);
return tdualquat<T, P>(q.real / s, q.dual / s);
}
//////////////////////////////////////
@ -249,8 +248,8 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator==
(
detail::tdualquat<T, P> const & q1,
detail::tdualquat<T, P> const & q2
tdualquat<T, P> const & q1,
tdualquat<T, P> const & q2
)
{
return (q1.real == q2.real) && (q1.dual == q2.dual);
@ -259,29 +258,28 @@ namespace detail
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator!=
(
detail::tdualquat<T, P> const & q1,
detail::tdualquat<T, P> const & q2
tdualquat<T, P> const & q1,
tdualquat<T, P> const & q2
)
{
return (q1.real != q2.dual) || (q1.real != q2.dual);
}
}//namespace detail
////////////////////////////////////////////////////////
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> normalize
GLM_FUNC_QUALIFIER tdualquat<T, P> normalize
(
detail::tdualquat<T, P> const & q
tdualquat<T, P> const & q
)
{
return q / length(q.real);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> lerp
GLM_FUNC_QUALIFIER tdualquat<T, P> lerp
(
detail::tdualquat<T, P> const & x,
detail::tdualquat<T, P> const & y,
tdualquat<T, P> const & x,
tdualquat<T, P> const & y,
T const & a
)
{
@ -291,38 +289,38 @@ namespace detail
assert(a <= static_cast<T>(1));
T const k = dot(x.real,y.real) < static_cast<T>(0) ? -a : a;
T const one(1);
return detail::tdualquat<T, P>(x * (one - a) + y * k);
return tdualquat<T, P>(x * (one - a) + y * k);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> inverse
GLM_FUNC_QUALIFIER tdualquat<T, P> inverse
(
detail::tdualquat<T, P> const & q
tdualquat<T, P> const & q
)
{
const glm::detail::tquat<T, P> real = conjugate(q.real);
const glm::detail::tquat<T, P> dual = conjugate(q.dual);
return detail::tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
const glm::tquat<T, P> real = conjugate(q.real);
const glm::tquat<T, P> dual = conjugate(q.dual);
return tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> mat2x4_cast
GLM_FUNC_QUALIFIER tmat2x4<T, P> mat2x4_cast
(
detail::tdualquat<T, P> const & x
tdualquat<T, P> const & x
)
{
return detail::tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
return tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> mat3x4_cast
GLM_FUNC_QUALIFIER tmat3x4<T, P> mat3x4_cast
(
detail::tdualquat<T, P> const & x
tdualquat<T, P> const & x
)
{
detail::tquat<T, P> r = x.real / length2(x.real);
tquat<T, P> r = x.real / length2(x.real);
detail::tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
r *= static_cast<T>(2);
T const xy = r.x * x.real.y;
@ -332,45 +330,45 @@ namespace detail
T const wy = r.w * x.real.y;
T const wz = r.w * x.real.z;
detail::tvec4<T, P> const a(
tvec4<T, P> const a(
rr.w + rr.x - rr.y - rr.z,
xy - wz,
xz + wy,
-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y));
detail::tvec4<T, P> const b(
tvec4<T, P> const b(
xy + wz,
rr.w + rr.y - rr.x - rr.z,
yz - wx,
-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x));
detail::tvec4<T, P> const c(
tvec4<T, P> const c(
xz - wy,
yz + wx,
rr.w + rr.z - rr.x - rr.y,
-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w));
return detail::tmat3x4<T, P>(a, b, c);
return tmat3x4<T, P>(a, b, c);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast
(
detail::tmat2x4<T, P> const & x
tmat2x4<T, P> const & x
)
{
return detail::tdualquat<T, P>(
detail::tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
detail::tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
return tdualquat<T, P>(
tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast
(
detail::tmat3x4<T, P> const & x
tmat3x4<T, P> const & x
)
{
detail::tquat<T, P> real;
tquat<T, P> real;
T const trace = x[0].x + x[1].y + x[2].z;
if(trace > T(0))
@ -410,12 +408,12 @@ namespace detail
real.w = (x[1].x - x[0].y) * invr;
}
detail::tquat<T, P> dual;
tquat<T, P> dual;
dual.x = T(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y);
dual.y = T(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x);
dual.z = T(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w);
dual.w = -T(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z);
return detail::tdualquat<T, P>(real, dual);
return tdualquat<T, P>(real, dual);
}
}//namespace glm

30
glm/gtx/euler_angles.hpp
View file

@ -53,67 +53,67 @@ namespace glm
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleX(
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleY(
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZ(
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXY(
T const & angleX,
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYX(
T const & angleY,
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXZ(
T const & angleX,
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZX(
T const & angle,
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYZ(
T const & angleY,
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZY(
T const & angleZ,
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYXZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYXZ(
T const & yaw,
T const & pitch,
T const & roll);
@ -121,7 +121,7 @@ namespace glm
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> yawPitchRoll(
GLM_FUNC_DECL tmat4x4<T, defaultp> yawPitchRoll(
T const & yaw,
T const & pitch,
T const & roll);
@ -129,22 +129,22 @@ namespace glm
/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> orientate2(T const & angle);
GLM_FUNC_DECL tmat2x2<T, defaultp> orientate2(T const & angle);
/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> orientate3(T const & angle);
GLM_FUNC_DECL tmat3x3<T, defaultp> orientate3(T const & angle);
/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> orientate3(detail::tvec3<T, P> const & angles);
GLM_FUNC_DECL tmat3x3<T, P> orientate3(tvec3<T, P> const & angles);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> orientate4(detail::tvec3<T, P> const & angles);
GLM_FUNC_DECL tmat4x4<T, P> orientate4(tvec3<T, P> const & angles);
/// @}
}//namespace glm

54
glm/gtx/euler_angles.inl
View file

@ -10,7 +10,7 @@
namespace glm
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleX
(
T const & angleX
)
@ -18,7 +18,7 @@ namespace glm
T cosX = glm::cos(angleX);
T sinX = glm::sin(angleX);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
T(1), T(0), T(0), T(0),
T(0), cosX, sinX, T(0),
T(0),-sinX, cosX, T(0),
@ -26,7 +26,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleY
(
T const & angleY
)
@ -34,7 +34,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, T(0), -sinY, T(0),
T(0), T(1), T(0), T(0),
sinY, T(0), cosY, T(0),
@ -42,7 +42,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZ
(
T const & angleZ
)
@ -50,7 +50,7 @@ namespace glm
T cosZ = glm::cos(angleZ);
T sinZ = glm::sin(angleZ);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosZ, sinZ, T(0), T(0),
-sinZ, cosZ, T(0), T(0),
T(0), T(0), T(1), T(0),
@ -58,7 +58,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXY
(
T const & angleX,
T const & angleY
@ -69,7 +69,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, -sinX * -sinY, cosX * -sinY, T(0),
T(0), cosX, sinX, T(0),
sinY, -sinX * cosY, cosX * cosY, T(0),
@ -77,7 +77,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYX
(
T const & angleY,
T const & angleX
@ -88,7 +88,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, 0, -sinY, T(0),
sinY * sinX, cosX, cosY * sinX, T(0),
sinY * cosX, -sinX, cosY * cosX, T(0),
@ -96,7 +96,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXZ
(
T const & angleX,
T const & angleZ
@ -106,7 +106,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZX
(
T const & angleZ,
T const & angleX
@ -116,7 +116,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYZ
(
T const & angleY,
T const & angleZ
@ -126,7 +126,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZY
(
T const & angleZ,
T const & angleY
@ -136,7 +136,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYXZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYXZ
(
T const & yaw,
T const & pitch,
@ -150,7 +150,7 @@ namespace glm
T tmp_cb = glm::cos(roll);
T tmp_sb = glm::sin(roll);
detail::tmat4x4<T, defaultp> Result;
tmat4x4<T, defaultp> Result;
Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
Result[0][1] = tmp_sb * tmp_cp;
Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@ -171,7 +171,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> yawPitchRoll
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> yawPitchRoll
(
T const & yaw,
T const & pitch,
@ -185,7 +185,7 @@ namespace glm
T tmp_cb = glm::cos(roll);
T tmp_sb = glm::sin(roll);
detail::tmat4x4<T, defaultp> Result;
tmat4x4<T, defaultp> Result;
Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
Result[0][1] = tmp_sb * tmp_cp;
Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@ -206,7 +206,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> orientate2
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> orientate2
(
T const & angle
)
@ -214,7 +214,7 @@ namespace glm
T c = glm::cos(angle);
T s = glm::sin(angle);
detail::tmat2x2<T, defaultp> Result;
tmat2x2<T, defaultp> Result;
Result[0][0] = c;
Result[0][1] = s;
Result[1][0] = -s;
@ -223,7 +223,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> orientate3
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> orientate3
(
T const & angle
)
@ -231,7 +231,7 @@ namespace glm
T c = glm::cos(angle);
T s = glm::sin(angle);
detail::tmat3x3<T, defaultp> Result;
tmat3x3<T, defaultp> Result;
Result[0][0] = c;
Result[0][1] = s;
Result[0][2] = 0.0f;
@ -245,18 +245,18 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> orientate3
GLM_FUNC_QUALIFIER tmat3x3<T, P> orientate3
(
detail::tvec3<T, P> const & angles
tvec3<T, P> const & angles
)
{
return detail::tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
return tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> orientate4
GLM_FUNC_QUALIFIER tmat4x4<T, P> orientate4
(
detail::tvec3<T, P> const & angles
tvec3<T, P> const & angles
)
{
return yawPitchRoll(angles.z, angles.x, angles.y);

18
glm/gtx/extend.inl
View file

@ -21,10 +21,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> extend
GLM_FUNC_QUALIFIER tvec2<T, P> extend
(
detail::tvec2<T, P> const & Origin,
detail::tvec2<T, P> const & Source,
tvec2<T, P> const & Origin,
tvec2<T, P> const & Source,
T const & Distance
)
{
@ -32,10 +32,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> extend
GLM_FUNC_QUALIFIER tvec3<T, P> extend
(
detail::tvec3<T, P> const & Origin,
detail::tvec3<T, P> const & Source,
tvec3<T, P> const & Origin,
tvec3<T, P> const & Source,
T const & Distance
)
{
@ -43,10 +43,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> extend
GLM_FUNC_QUALIFIER tvec4<T, P> extend
(
detail::tvec4<T, P> const & Origin,
detail::tvec4<T, P> const & Source,
tvec4<T, P> const & Origin,
tvec4<T, P> const & Source,
T const & Distance
)
{

24
glm/gtx/fast_exponential.inl
View file

@ -28,32 +28,32 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> fastPow(
const detail::tvec2<T, P>& x,
const detail::tvec2<int, P>& y)
GLM_FUNC_QUALIFIER tvec2<T, P> fastPow(
const tvec2<T, P>& x,
const tvec2<int, P>& y)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> fastPow(
const detail::tvec3<T, P>& x,
const detail::tvec3<int, P>& y)
GLM_FUNC_QUALIFIER tvec3<T, P> fastPow(
const tvec3<T, P>& x,
const tvec3<int, P>& y)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> fastPow(
const detail::tvec4<T, P>& x,
const detail::tvec4<int, P>& y)
GLM_FUNC_QUALIFIER tvec4<T, P> fastPow(
const tvec4<T, P>& x,
const tvec4<int, P>& y)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z),

38
glm/gtx/fast_square_root.inl
View file

@ -28,10 +28,10 @@ namespace glm
GLM_FUNC_QUALIFIER float fastInverseSqrt<float>(float const & x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)));
tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)));
return tmp.x;
# else
return detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)).x;
return detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)).x;
# endif
}
@ -39,10 +39,10 @@ namespace glm
GLM_FUNC_QUALIFIER double fastInverseSqrt<double>(double const & x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)));
tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)));
return tmp.x;
# else
return detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)).x;
return detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)).x;
# endif
}
@ -70,7 +70,7 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec2<valType, P> const & x
tvec2<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y;
@ -80,7 +80,7 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec3<valType, P> const & x
tvec3<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
@ -90,7 +90,7 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec4<valType, P> const & x
tvec4<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
@ -111,8 +111,8 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastDistance
(
detail::tvec2<valType, P> const & x,
detail::tvec2<valType, P> const & y
tvec2<valType, P> const & x,
tvec2<valType, P> const & y
)
{
return fastLength(y - x);
@ -121,8 +121,8 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastDistance
(
detail::tvec3<valType, P> const & x,
detail::tvec3<valType, P> const & y
tvec3<valType, P> const & x,
tvec3<valType, P> const & y
)
{
return fastLength(y - x);
@ -131,8 +131,8 @@ namespace glm
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastDistance
(
detail::tvec4<valType, P> const & x,
detail::tvec4<valType, P> const & y
tvec4<valType, P> const & x,
tvec4<valType, P> const & y
)
{
return fastLength(y - x);
@ -149,9 +149,9 @@ namespace glm
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<valType, P> fastNormalize
GLM_FUNC_QUALIFIER tvec2<valType, P> fastNormalize
(
detail::tvec2<valType, P> const & x
tvec2<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y;
@ -159,9 +159,9 @@ namespace glm
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<valType, P> fastNormalize
GLM_FUNC_QUALIFIER tvec3<valType, P> fastNormalize
(
detail::tvec3<valType, P> const & x
tvec3<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
@ -169,9 +169,9 @@ namespace glm
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<valType, P> fastNormalize
GLM_FUNC_QUALIFIER tvec4<valType, P> fastNormalize
(
detail::tvec4<valType, P> const & x
tvec4<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;

12
glm/gtx/gradient_paint.hpp
View file

@ -54,18 +54,18 @@ namespace glm
/// @see - gtx_gradient_paint
template <typename T, precision P>
GLM_FUNC_DECL T radialGradient(
detail::tvec2<T, P> const & Center,
tvec2<T, P> const & Center,
T const & Radius,
detail::tvec2<T, P> const & Focal,
detail::tvec2<T, P> const & Position);
tvec2<T, P> const & Focal,
tvec2<T, P> const & Position);
/// Return a color from a linear gradient.
/// @see - gtx_gradient_paint
template <typename T, precision P>
GLM_FUNC_DECL T linearGradient(
detail::tvec2<T, P> const & Point0,
detail::tvec2<T, P> const & Point1,
detail::tvec2<T, P> const & Position);
tvec2<T, P> const & Point0,
tvec2<T, P> const & Point1,
tvec2<T, P> const & Position);
/// @}
}// namespace glm

18
glm/gtx/gradient_paint.inl
View file

@ -12,14 +12,14 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T radialGradient
(
detail::tvec2<T, P> const & Center,
tvec2<T, P> const & Center,
T const & Radius,
detail::tvec2<T, P> const & Focal,
detail::tvec2<T, P> const & Position
tvec2<T, P> const & Focal,
tvec2<T, P> const & Position
)
{
detail::tvec2<T, P> F = Focal - Center;
detail::tvec2<T, P> D = Position - Focal;
tvec2<T, P> F = Focal - Center;
tvec2<T, P> D = Position - Focal;
T Radius2 = pow2(Radius);
T Fx2 = pow2(F.x);
T Fy2 = pow2(F.y);
@ -32,12 +32,12 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T linearGradient
(
detail::tvec2<T, P> const & Point0,
detail::tvec2<T, P> const & Point1,
detail::tvec2<T, P> const & Position
tvec2<T, P> const & Point0,
tvec2<T, P> const & Point1,
tvec2<T, P> const & Position
)
{
detail::tvec2<T, P> Dist = Point1 - Point0;
tvec2<T, P> Dist = Point1 - Point0;
return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
}
}//namespace glm

12
glm/gtx/handed_coordinate_space.hpp
View file

@ -53,17 +53,17 @@ namespace glm
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T, precision P>
GLM_FUNC_DECL bool rightHanded(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal);
//! Return if a trihedron left handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T, precision P>
GLM_FUNC_DECL bool leftHanded(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal);
/// @}
}// namespace glm

12
glm/gtx/handed_coordinate_space.inl
View file

@ -12,9 +12,9 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool rightHanded
(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal
)
{
return dot(cross(normal, tangent), binormal) > T(0);
@ -23,9 +23,9 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool leftHanded
(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal
)
{
return dot(cross(normal, tangent), binormal) < T(0);

20
glm/gtx/inertia.hpp
View file

@ -54,56 +54,56 @@ namespace glm
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> boxInertia3(
tmat3x3<T, P> boxInertia3(
T const & Mass,
detail::tvec3<T, P> const & Scale);
tvec3<T, P> const & Scale);
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> boxInertia4(
tmat4x4<T, P> boxInertia4(
T const & Mass,
detail::tvec3<T, P> const & Scale);
tvec3<T, P> const & Scale);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> diskInertia3(
tmat3x3<T, P> diskInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> diskInertia4(
tmat4x4<T, P> diskInertia4(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> ballInertia3(
tmat3x3<T, P> ballInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> ballInertia4(
tmat4x4<T, P> ballInertia4(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> sphereInertia3(
tmat3x3<T, P> sphereInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> sphereInertia4(
tmat4x4<T, P> sphereInertia4(
T const & Mass,
T const & Radius);
*/

36
glm/gtx/inertia.inl
View file

@ -11,13 +11,13 @@ namespace glm
{
/*
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> boxInertia3
GLM_FUNC_QUALIFIER tmat3x3<T, P> boxInertia3
(
T const & Mass,
detail::tvec3<T, P> const & Scale
tvec3<T, P> const & Scale
)
{
detail::tmat3x3<T, P> Result(T(1));
tmat3x3<T, P> Result(T(1));
Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
@ -25,13 +25,13 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> boxInertia4
GLM_FUNC_QUALIFIER tmat4x4<T, P> boxInertia4
(
T const & Mass,
detail::tvec3<T, P> const & Scale
tvec3<T, P> const & Scale
)
{
detail::tmat4x4<T, P> Result(T(1));
tmat4x4<T, P> Result(T(1));
Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
@ -39,76 +39,76 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diskInertia3
GLM_FUNC_QUALIFIER tmat3x3<T, P> diskInertia3
(
T const & Mass,
T const & Radius
)
{
T a = Mass * Radius * Radius / T(2);
detail::tmat3x3<T, P> Result(a);
tmat3x3<T, P> Result(a);
Result[2][2] *= static_cast<T>(2);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diskInertia4
GLM_FUNC_QUALIFIER tmat4x4<T, P> diskInertia4
(
T const & Mass,
T const & Radius
)
{
T a = Mass * Radius * Radius / T(2);
detail::tmat4x4<T, P> Result(a);
tmat4x4<T, P> Result(a);
Result[2][2] *= static_cast<T>(2);
Result[3][3] = static_cast<T>(1);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> ballInertia3
GLM_FUNC_QUALIFIER tmat3x3<T, P> ballInertia3
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
return detail::tmat3x3<T, P>(a);
return tmat3x3<T, P>(a);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> ballInertia4
GLM_FUNC_QUALIFIER tmat4x4<T, P> ballInertia4
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
detail::tmat4x4<T, P> Result(a);
tmat4x4<T, P> Result(a);
Result[3][3] = static_cast<T>(1);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> sphereInertia3
GLM_FUNC_QUALIFIER tmat3x3<T, P> sphereInertia3
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
return detail::tmat3x3<T, P>(a);
return tmat3x3<T, P>(a);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> sphereInertia4
GLM_FUNC_QUALIFIER tmat4x4<T, P> sphereInertia4
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
detail::tmat4x4<T, P> Result(a);
tmat4x4<T, P> Result(a);
Result[3][3] = static_cast<T>(1);
return Result;
}

18
glm/gtx/integer.inl
View file

@ -100,29 +100,29 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> factorial(
detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<T, P> factorial(
tvec2<T, P> const & x)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
factorial(x.x),
factorial(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> factorial(
detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<T, P> factorial(
tvec3<T, P> const & x)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
factorial(x.x),
factorial(x.y),
factorial(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> factorial(
detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<T, P> factorial(
tvec4<T, P> const & x)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
factorial(x.x),
factorial(x.y),
factorial(x.z),

65
glm/gtx/io.hpp
View file

@ -181,41 +181,38 @@ namespace glm
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
}//namespace io
namespace detail
{
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
std::basic_ostream<CTy,CTr> &,
std::pair<tmat4x4<T,P> const,
tmat4x4<T,P> const> const &);
}//namespace detail
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
std::basic_ostream<CTy,CTr> &,
std::pair<tmat4x4<T,P> const,
tmat4x4<T,P> const> const &);
/// @}
}//namespace glm

3
glm/gtx/io.inl
View file

@ -162,8 +162,6 @@ namespace io
}
} // namespace io
namespace detail
{
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a)
{
@ -594,5 +592,4 @@ namespace detail
return os;
}
}//namespace detail
}//namespace glm

8
glm/gtx/matrix_cross_product.hpp
View file

@ -53,14 +53,14 @@ namespace glm
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> matrixCross3(
detail::tvec3<T, P> const & x);
GLM_FUNC_DECL tmat3x3<T, P> matrixCross3(
tvec3<T, P> const & x);
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> matrixCross4(
detail::tvec3<T, P> const & x);
GLM_FUNC_DECL tmat4x4<T, P> matrixCross4(
tvec3<T, P> const & x);
/// @}
}//namespace glm

12
glm/gtx/matrix_cross_product.inl
View file

@ -10,12 +10,12 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> matrixCross3
GLM_FUNC_QUALIFIER tmat3x3<T, P> matrixCross3
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
detail::tmat3x3<T, P> Result(T(0));
tmat3x3<T, P> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
@ -26,12 +26,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> matrixCross4
GLM_FUNC_QUALIFIER tmat4x4<T, P> matrixCross4
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
detail::tmat4x4<T, P> Result(T(0));
tmat4x4<T, P> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;

4
glm/gtx/matrix_decompose.hpp
View file

@ -57,8 +57,8 @@ namespace glm
/// @see gtx_decomposition
template <typename T, precision P>
GLM_FUNC_DECL bool decompose(
detail::tmat4x4<T, P> const & modelMatrix,
detail::tvec3<T, P> & scale, detail::tquat<T, P> & orientation, detail::tvec3<T, P> & translation, detail::tvec3<T, P> & skew, detail::tvec4<T, P> & perspective);
tmat4x4<T, P> const & modelMatrix,
tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
/// @}
}//namespace glm

28
glm/gtx/matrix_decompose.inl
View file

@ -31,16 +31,16 @@ namespace glm
/// Make a linear combination of two vectors and return the result.
// result = (a * ascl) + (b * bscl)
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> combine(
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b,
GLM_FUNC_QUALIFIER tvec3<T, P> combine(
tvec3<T, P> const & a,
tvec3<T, P> const & b,
T ascl, T bscl)
{
return (a * ascl) + (b * bscl);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER void v3Scale(detail::tvec3<T, P> & v, T desiredLength)
GLM_FUNC_QUALIFIER void v3Scale(tvec3<T, P> & v, T desiredLength)
{
T len = glm::length(v);
if(len != 0)
@ -60,9 +60,9 @@ namespace glm
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool decompose(detail::tmat4x4<T, P> const & ModelMatrix, detail::tvec3<T, P> & Scale, detail::tquat<T, P> & Orientation, detail::tvec3<T, P> & Translation, detail::tvec3<T, P> & Skew, detail::tvec4<T, P> & Perspective)
GLM_FUNC_QUALIFIER bool decompose(tmat4x4<T, P> const & ModelMatrix, tvec3<T, P> & Scale, tquat<T, P> & Orientation, tvec3<T, P> & Translation, tvec3<T, P> & Skew, tvec4<T, P> & Perspective)
{
detail::tmat4x4<T, P> LocalMatrix(ModelMatrix);
tmat4x4<T, P> LocalMatrix(ModelMatrix);
// Normalize the matrix.
if(LocalMatrix[3][3] == static_cast<T>(0))
@ -74,7 +74,7 @@ namespace glm
// perspectiveMatrix is used to solve for perspective, but it also provides
// an easy way to test for singularity of the upper 3x3 component.
detail::tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
for(length_t i = 0; i < 3; i++)
PerspectiveMatrix[i][3] = 0;
@ -88,7 +88,7 @@ namespace glm
if(LocalMatrix[0][3] != 0 || LocalMatrix[1][3] != 0 || LocalMatrix[2][3] != 0)
{
// rightHandSide is the right hand side of the equation.
detail::tvec4<T, P> RightHandSide;
tvec4<T, P> RightHandSide;
RightHandSide[0] = LocalMatrix[0][3];
RightHandSide[1] = LocalMatrix[1][3];
RightHandSide[2] = LocalMatrix[2][3];
@ -97,8 +97,8 @@ namespace glm
// Solve the equation by inverting PerspectiveMatrix and multiplying
// rightHandSide by the inverse. (This is the easiest way, not
// necessarily the best.)
detail::tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix);
detail::tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix);
tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
Perspective = TransposedInversePerspectiveMatrix * RightHandSide;
// v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint);
@ -110,14 +110,14 @@ namespace glm
else
{
// No perspective.
Perspective = detail::tvec4<T, P>(0, 0, 0, 1);
Perspective = tvec4<T, P>(0, 0, 0, 1);
}
// Next take care of translation (easy).
Translation = detail::tvec3<T, P>(LocalMatrix[3]);
LocalMatrix[3] = detail::tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
Translation = tvec3<T, P>(LocalMatrix[3]);
LocalMatrix[3] = tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
detail::tvec3<T, P> Row[3], Pdum3;
tvec3<T, P> Row[3], Pdum3;
// Now get scale and shear.
for(length_t i = 0; i < 3; ++i)

18
glm/gtx/matrix_interpolation.hpp
View file

@ -53,30 +53,30 @@ namespace glm
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL void axisAngle(
detail::tmat4x4<T, P> const & mat,
detail::tvec3<T, P> & axis,
tmat4x4<T, P> const & mat,
tvec3<T, P> & axis,
T & angle);
/// Build a matrix from axis and angle.
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> axisAngleMatrix(
detail::tvec3<T, P> const & axis,
GLM_FUNC_DECL tmat4x4<T, P> axisAngleMatrix(
tvec3<T, P> const & axis,
T const angle);
/// Extracts the rotation part of a matrix.
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> extractMatrixRotation(
detail::tmat4x4<T, P> const & mat);
GLM_FUNC_DECL tmat4x4<T, P> extractMatrixRotation(
tmat4x4<T, P> const & mat);
/// Build a interpolation of 4 * 4 matrixes.
/// From GLM_GTX_matrix_interpolation extension.
/// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> interpolate(
detail::tmat4x4<T, P> const & m1,
detail::tmat4x4<T, P> const & m2,
GLM_FUNC_DECL tmat4x4<T, P> interpolate(
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2,
T const delta);
/// @}

32
glm/gtx/matrix_interpolation.inl
View file

@ -12,8 +12,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER void axisAngle
(
detail::tmat4x4<T, P> const & mat,
detail::tvec3<T, P> & axis,
tmat4x4<T, P> const & mat,
tvec3<T, P> & axis,
T & angle
)
{
@ -85,18 +85,18 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> axisAngleMatrix
GLM_FUNC_QUALIFIER tmat4x4<T, P> axisAngleMatrix
(
detail::tvec3<T, P> const & axis,
tvec3<T, P> const & axis,
T const angle
)
{
T c = cos(angle);
T s = sin(angle);
T t = static_cast<T>(1) - c;
detail::tvec3<T, P> n = normalize(axis);
tvec3<T, P> n = normalize(axis);
return detail::tmat4x4<T, P>(
return tmat4x4<T, P>(
t * n.x * n.x + c, t * n.x * n.y + n.z * s, t * n.x * n.z - n.y * s, T(0),
t * n.x * n.y - n.z * s, t * n.y * n.y + c, t * n.y * n.z + n.x * s, T(0),
t * n.x * n.z + n.y * s, t * n.y * n.z - n.x * s, t * n.z * n.z + c, T(0),
@ -105,12 +105,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> extractMatrixRotation
GLM_FUNC_QUALIFIER tmat4x4<T, P> extractMatrixRotation
(
detail::tmat4x4<T, P> const & mat
tmat4x4<T, P> const & mat
)
{
return detail::tmat4x4<T, P>(
return tmat4x4<T, P>(
mat[0][0], mat[0][1], mat[0][2], 0.0,
mat[1][0], mat[1][1], mat[1][2], 0.0,
mat[2][0], mat[2][1], mat[2][2], 0.0,
@ -119,19 +119,19 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> interpolate
GLM_FUNC_QUALIFIER tmat4x4<T, P> interpolate
(
detail::tmat4x4<T, P> const & m1,
detail::tmat4x4<T, P> const & m2,
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2,
T const delta
)
{
detail::tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
detail::tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
detail::tvec3<T, P> dltAxis;
tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
tvec3<T, P> dltAxis;
T dltAngle;
axisAngle(dltRotation, dltAxis, dltAngle);
detail::tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);

72
glm/gtx/matrix_major_storage.hpp
View file

@ -53,86 +53,86 @@ namespace glm
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2);
GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
tvec2<T, P> const & v1,
tvec2<T, P> const & v2);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
detail::tmat2x2<T, P> const & m);
GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
tmat2x2<T, P> const & m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
detail::tmat3x3<T, P> const & m);
GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
tmat3x3<T, P> const & m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
detail::tvec4<T, P> const & v1,
detail::tvec4<T, P> const & v2,
detail::tvec4<T, P> const & v3,
detail::tvec4<T, P> const & v4);
GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
tvec4<T, P> const & v1,
tvec4<T, P> const & v2,
tvec4<T, P> const & v3,
tvec4<T, P> const & v4);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
detail::tmat4x4<T, P> const & m);
GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
tmat4x4<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2);
GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
tvec2<T, P> const & v1,
tvec2<T, P> const & v2);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
detail::tmat2x2<T, P> const & m);
GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
tmat2x2<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
detail::tmat3x3<T, P> const & m);
GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
tmat3x3<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
detail::tvec4<T, P> const & v1,
detail::tvec4<T, P> const & v2,
detail::tvec4<T, P> const & v3,
detail::tvec4<T, P> const & v4);
GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
tvec4<T, P> const & v1,
tvec4<T, P> const & v2,
tvec4<T, P> const & v3,
tvec4<T, P> const & v4);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
detail::tmat4x4<T, P> const & m);
GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
tmat4x4<T, P> const & m);
/// @}
}//namespace glm

96
glm/gtx/matrix_major_storage.inl
View file

@ -10,13 +10,13 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2
GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2
(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2
tvec2<T, P> const & v1,
tvec2<T, P> const & v2
)
{
detail::tmat2x2<T, P> Result;
tmat2x2<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[0][1] = v2.x;
@ -25,10 +25,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2(
const detail::tmat2x2<T, P>& m)
GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2(
const tmat2x2<T, P>& m)
{
detail::tmat2x2<T, P> Result;
tmat2x2<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[1][0] = m[0][1];
@ -37,12 +37,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
const detail::tvec3<T, P>& v1,
const detail::tvec3<T, P>& v2,
const detail::tvec3<T, P>& v3)
GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
const tvec3<T, P>& v1,
const tvec3<T, P>& v2,
const tvec3<T, P>& v3)
{
detail::tmat3x3<T, P> Result;
tmat3x3<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[2][0] = v1.z;
@ -56,10 +56,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
const detail::tmat3x3<T, P>& m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
const tmat3x3<T, P>& m)
{
detail::tmat3x3<T, P> Result;
tmat3x3<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[0][2] = m[2][0];
@ -73,13 +73,13 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
const detail::tvec4<T, P>& v1,
const detail::tvec4<T, P>& v2,
const detail::tvec4<T, P>& v3,
const detail::tvec4<T, P>& v4)
GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
const tvec4<T, P>& v1,
const tvec4<T, P>& v2,
const tvec4<T, P>& v3,
const tvec4<T, P>& v4)
{
detail::tmat4x4<T, P> Result;
tmat4x4<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[2][0] = v1.z;
@ -100,10 +100,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
const detail::tmat4x4<T, P>& m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
const tmat4x4<T, P>& m)
{
detail::tmat4x4<T, P> Result;
tmat4x4<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[0][2] = m[2][0];
@ -124,50 +124,50 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
const detail::tvec2<T, P>& v1,
const detail::tvec2<T, P>& v2)
GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
const tvec2<T, P>& v1,
const tvec2<T, P>& v2)
{
return detail::tmat2x2<T, P>(v1, v2);
return tmat2x2<T, P>(v1, v2);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
const detail::tmat2x2<T, P>& m)
GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
const tmat2x2<T, P>& m)
{
return detail::tmat2x2<T, P>(m);
return tmat2x2<T, P>(m);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
const detail::tvec3<T, P>& v1,
const detail::tvec3<T, P>& v2,
const detail::tvec3<T, P>& v3)
GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
const tvec3<T, P>& v1,
const tvec3<T, P>& v2,
const tvec3<T, P>& v3)
{
return detail::tmat3x3<T, P>(v1, v2, v3);
return tmat3x3<T, P>(v1, v2, v3);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
const detail::tmat3x3<T, P>& m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
const tmat3x3<T, P>& m)
{
return detail::tmat3x3<T, P>(m);
return tmat3x3<T, P>(m);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
const detail::tvec4<T, P>& v1,
const detail::tvec4<T, P>& v2,
const detail::tvec4<T, P>& v3,
const detail::tvec4<T, P>& v4)
GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
const tvec4<T, P>& v1,
const tvec4<T, P>& v2,
const tvec4<T, P>& v3,
const tvec4<T, P>& v4)
{
return detail::tmat4x4<T, P>(v1, v2, v3, v4);
return tmat4x4<T, P>(v1, v2, v3, v4);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
const detail::tmat4x4<T, P>& m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
const tmat4x4<T, P>& m)
{
return detail::tmat4x4<T, P>(m);
return tmat4x4<T, P>(m);
}
}//namespace glm

36
glm/gtx/matrix_operation.hpp
View file

@ -52,56 +52,56 @@ namespace glm
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> diagonal2x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x2<T, P> diagonal2x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x3<T, P> diagonal2x3(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x3<T, P> diagonal2x3(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x4<T, P> diagonal2x4(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x4<T, P> diagonal2x4(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x2<T, P> diagonal3x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat3x2<T, P> diagonal3x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> diagonal3x3(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat3x3<T, P> diagonal3x3(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x4<T, P> diagonal3x4(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat3x4<T, P> diagonal3x4(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x2<T, P> diagonal4x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat4x2<T, P> diagonal4x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x3<T, P> diagonal4x3(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat4x3<T, P> diagonal4x3(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> diagonal4x4(
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tmat4x4<T, P> diagonal4x4(
tvec4<T, P> const & v);
/// @}
}//namespace glm

54
glm/gtx/matrix_operation.inl
View file

@ -10,60 +10,60 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> diagonal2x2
GLM_FUNC_QUALIFIER tmat2x2<T, P> diagonal2x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x2<T, P> Result(static_cast<T>(1));
tmat2x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x3<T, P> diagonal2x3
GLM_FUNC_QUALIFIER tmat2x3<T, P> diagonal2x3
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x3<T, P> Result(static_cast<T>(1));
tmat2x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> diagonal2x4
GLM_FUNC_QUALIFIER tmat2x4<T, P> diagonal2x4
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x4<T, P> Result(static_cast<T>(1));
tmat2x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x2<T, P> diagonal3x2
GLM_FUNC_QUALIFIER tmat3x2<T, P> diagonal3x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat3x2<T, P> Result(static_cast<T>(1));
tmat3x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diagonal3x3
GLM_FUNC_QUALIFIER tmat3x3<T, P> diagonal3x3
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat3x3<T, P> Result(static_cast<T>(1));
tmat3x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@ -71,12 +71,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> diagonal3x4
GLM_FUNC_QUALIFIER tmat3x4<T, P> diagonal3x4
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat3x4<T, P> Result(static_cast<T>(1));
tmat3x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@ -84,12 +84,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diagonal4x4
GLM_FUNC_QUALIFIER tmat4x4<T, P> diagonal4x4
(
detail::tvec4<T, P> const & v
tvec4<T, P> const & v
)
{
detail::tmat4x4<T, P> Result(static_cast<T>(1));
tmat4x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@ -98,12 +98,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x3<T, P> diagonal4x3
GLM_FUNC_QUALIFIER tmat4x3<T, P> diagonal4x3
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat4x3<T, P> Result(static_cast<T>(1));
tmat4x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@ -111,12 +111,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x2<T, P> diagonal4x2
GLM_FUNC_QUALIFIER tmat4x2<T, P> diagonal4x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat4x2<T, P> Result(static_cast<T>(1));
tmat4x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;

12
glm/gtx/matrix_query.hpp
View file

@ -55,17 +55,17 @@ namespace glm
/// Return whether a matrix a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat2x2<T, P> const & m, T const & epsilon);
/// Return whether a matrix a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat3x3<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat4x4<T, P> const & m, T const & epsilon);
/// Return whether a matrix is an identity matrix.
/// From GLM_GTX_matrix_query extension.
@ -75,17 +75,17 @@ namespace glm
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon);
/// Return whether a matrix is an orthonormalized matrix.
/// From GLM_GTX_matrix_query extension.

18
glm/gtx/matrix_query.inl
View file

@ -13,7 +13,7 @@
namespace glm
{
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat2x2<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 2 ; ++i)
@ -22,7 +22,7 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat3x3<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 3 ; ++i)
@ -31,7 +31,7 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat4x4<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 4 ; ++i)
@ -56,14 +56,14 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
{
typename detail::tmat2x2<T, P>::col_type v;
typename tmat2x2<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);
@ -72,14 +72,14 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
{
typename detail::tmat3x3<T, P>::col_type v;
typename tmat3x3<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);
@ -88,14 +88,14 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
{
typename detail::tmat4x4<T, P>::col_type v;
typename tmat4x4<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);

24
glm/gtx/matrix_transform_2d.hpp
View file

@ -56,17 +56,17 @@ namespace glm
/// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a translation vector.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v);
GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v);
/// Builds a rotation 3 * 3 matrix created from an angle.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
tmat3x3<T, P> const & m,
T const & angle);
/// Builds a scale 3 * 3 matrix created from a vector of 2 components.
@ -74,17 +74,17 @@ namespace glm
/// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a scale vector.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v);
GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v);
/// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param y Shear factor.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
tmat3x3<T, P> const & m,
T const & y);
/// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix.
@ -92,8 +92,8 @@ namespace glm
/// @param m Input matrix multiplied by this translation matrix.
/// @param x Shear factor.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
tmat3x3<T, P> const & m,
T const & x);
/// @}

34
glm/gtx/matrix_transform_2d.inl
View file

@ -32,26 +32,26 @@ namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v)
{
detail::tmat3x3<T, P> Result(m);
tmat3x3<T, P> Result(m);
Result[2] = m[0] * v[0] + m[1] * v[1] + m[2];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
tmat3x3<T, P> const & m,
T const & angle)
{
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> Result(tmat3x3<T, P>::_null);
Result[0] = m[0] * c + m[1] * s;
Result[1] = m[0] * -s + m[1] * c;
Result[2] = m[2];
@ -59,11 +59,11 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v)
{
detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> Result(tmat3x3<T, P>::_null);
Result[0] = m[0] * v[0];
Result[1] = m[1] * v[1];
Result[2] = m[2];
@ -71,21 +71,21 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
tmat3x3<T, P> const & m,
T const & y)
{
detail::tmat3x3<T, P> Result();
tmat3x3<T, P> Result();
Result[0][1] = y;
return m * Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
detail::tmat3x3<T, P> const & m,
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
tmat3x3<T, P> const & m,
T const & x)
{
detail::tmat3x3<T, P> Result();
tmat3x3<T, P> Result();
Result[1][0] = x;
return m * Result;
}

6
glm/gtx/mixed_product.hpp
View file

@ -52,9 +52,9 @@ namespace glm
/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
template <typename T, precision P>
GLM_FUNC_DECL T mixedProduct(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
/// @}
}// namespace glm

6
glm/gtx/mixed_product.inl
View file

@ -12,9 +12,9 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T mixedProduct
(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3
)
{
return dot(cross(v1, v2), v3);

18
glm/gtx/norm.hpp
View file

@ -81,41 +81,41 @@ namespace glm
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
tvec3<T, P> const & x,
tvec3<T, P> const & y);
//! Returns the L1 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
detail::tvec3<T, P> const & v);
tvec3<T, P> const & v);
//! Returns the L2 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
tvec3<T, P> const & x,
tvec3<T, P> const & y);
//! Returns the L2 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
detail::tvec3<T, P> const & x);
tvec3<T, P> const & x);
//! Returns the L norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y,
tvec3<T, P> const & x,
tvec3<T, P> const & y,
unsigned int Depth);
//! Returns the L norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
detail::tvec3<T, P> const & x,
tvec3<T, P> const & x,
unsigned int Depth);
/// @}

Some files were not shown because too many files have changed in this diff Show more