mewin/glm
1
0
Fork 0
Code Releases Activity

Fixed merge

Browse Source
This commit is contained in:
Christophe Riccio 2013-05-27 14:54:02 +00:00
commit cf41c03c94
24 changed files with 463 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
glm/core/_swizzle.hpp
View File

@ -191,7 +191,7 @@ namespace detail
typedef ValueType value_type; typedef ValueType value_type;
struct Stub {}; struct Stub {};
_swizzle_base2& operator= (Stub const &) {} _swizzle_base2& operator= (Stub const &) { return *this; }
value_type operator[] (size_t i) const value_type operator[] (size_t i) const
{ {
@ -640,22 +640,22 @@ namespace glm
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E2 ## E0 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E2 ## E0 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E2 ## E0 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E2 ## E0 ## E3; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E2 ## E1 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E2 ## E1 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E2 ## E1 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E2 ## E1 ## E3; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E2 ## E2 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E2 ## E2 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E2 ## E2 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E2 ## E2 ## E3; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E2 ## E3 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E2 ## E3 ## E3; }; \ struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
@ -847,6 +847,6 @@ namespace glm
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \ struct { _swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \ struct { _swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \ struct { _swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; }; struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
#endif//glm_core_swizzle #endif//glm_core_swizzle

75
glm/core/func_common.hpp
View File

@ -51,7 +51,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType abs(genType const & x); GLM_FUNC_DECL genType abs(genType const & x);
/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
/// ///
@ -60,8 +60,8 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType sign(genType const & x); GLM_FUNC_DECL genType sign(genType const & x);
/// Returns a value equal to the nearest integer that is less then or equal to x. /// Returns a value equal to the nearest integer that is less then or equal to x.
/// ///
/// @tparam genType Floating-point scalar or vector types. /// @tparam genType Floating-point scalar or vector types.
@ -69,7 +69,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType floor(genType const & x); GLM_FUNC_DECL genType floor(genType const & x);
/// Returns a value equal to the nearest integer to x /// Returns a value equal to the nearest integer to x
/// whose absolute value is not larger than the absolute value of x. /// whose absolute value is not larger than the absolute value of x.
@ -79,7 +79,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType trunc(genType const & x); GLM_FUNC_DECL genType trunc(genType const & x);
/// Returns a value equal to the nearest integer to x. /// Returns a value equal to the nearest integer to x.
/// The fraction 0.5 will round in a direction chosen by the /// The fraction 0.5 will round in a direction chosen by the
@ -92,8 +92,8 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType round(genType const & x); GLM_FUNC_DECL genType round(genType const & x);
/// Returns a value equal to the nearest integer to x. /// Returns a value equal to the nearest integer to x.
/// A fractional part of 0.5 will round toward the nearest even /// A fractional part of 0.5 will round toward the nearest even
/// integer. (Both 3.5 and 4.5 for x will return 4.0.) /// integer. (Both 3.5 and 4.5 for x will return 4.0.)
@ -104,7 +104,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a> /// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
template <typename genType> template <typename genType>
genType roundEven(genType const & x); GLM_FUNC_DECL genType roundEven(genType const & x);
/// Returns a value equal to the nearest integer /// Returns a value equal to the nearest integer
/// that is greater than or equal to x. /// that is greater than or equal to x.
@ -114,7 +114,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType ceil(genType const & x); GLM_FUNC_DECL genType ceil(genType const & x);
/// Return x - floor(x). /// Return x - floor(x).
/// ///
@ -123,7 +123,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType fract(genType const & x); GLM_FUNC_DECL genType fract(genType const & x);
/// Modulus. Returns x - y * floor(x / y) /// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y. /// for each component in x using the floating point value y.
@ -133,7 +133,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType mod( GLM_FUNC_DECL genType mod(
genType const & x, genType const & x,
genType const & y); genType const & y);
@ -145,7 +145,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType mod( GLM_FUNC_DECL genType mod(
genType const & x, genType const & x,
typename genType::value_type const & y); typename genType::value_type const & y);
@ -159,7 +159,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType modf( GLM_FUNC_DECL genType modf(
genType const & x, genType const & x,
genType & i); genType & i);
@ -168,14 +168,14 @@ namespace glm
/// @tparam genType Floating-point or integer; scalar or vector types. /// @tparam genType Floating-point or integer; scalar or vector types.
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a><<<<<<< HEAD
template <typename genType> template <typename genType>
genType min( GLM_FUNC_DECL genType min(
genType const & x, genType const & x,
genType const & y); genType const & y);
template <typename genType> template <typename genType>
genType min( GLM_FUNC_DECL genType min(
genType const & x, genType const & x,
typename genType::value_type const & y); typename genType::value_type const & y);
@ -186,12 +186,12 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType max( GLM_FUNC_DECL genType max(
genType const & x, genType const & x,
genType const & y); genType const & y);
template <typename genType> template <typename genType>
genType max( GLM_FUNC_DECL genType max(
genType const & x, genType const & x,
typename genType::value_type const & y); typename genType::value_type const & y);
@ -203,13 +203,13 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType clamp( GLM_FUNC_DECL genType clamp(
genType const & x, genType const & x,
genType const & minVal, genType const & minVal,
genType const & maxVal); genType const & maxVal);
template <typename genType, precision P> template <typename genType, precision P>
genType clamp( GLM_FUNC_DECL genType clamp(
genType const & x, genType const & x,
typename genType::value_type const & minVal, typename genType::value_type const & minVal,
typename genType::value_type const & maxVal); typename genType::value_type const & maxVal);
@ -257,19 +257,22 @@ namespace glm
/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter. /// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
/// @endcode /// @endcode
template <typename genTypeT, typename genTypeU> template <typename genTypeT, typename genTypeU>
genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a); GLM_FUNC_DECL genTypeT mix(
genTypeT const & x,
genTypeT const & y,
genTypeU const & a);
//! Returns 0.0 if x < edge, otherwise it returns 1.0. /// Returns 0.0 if x < edge, otherwise it returns 1.0.
//! ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType step( GLM_FUNC_DECL genType step(
genType const & edge, genType const & edge,
genType const & x); genType const & x);
template <typename genType> template <typename genType>
genType step( GLM_FUNC_DECL genType step(
typename genType::value_type const & edge, typename genType::value_type const & edge,
genType const & x); genType const & x);
@ -288,13 +291,13 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType smoothstep( GLM_FUNC_DECL genType smoothstep(
genType const & edge0, genType const & edge0,
genType const & edge1, genType const & edge1,
genType const & x); genType const & x);
template <typename genType> template <typename genType>
genType smoothstep( GLM_FUNC_DECL genType smoothstep(
typename genType::value_type const & edge0, typename genType::value_type const & edge0,
typename genType::value_type const & edge1, typename genType::value_type const & edge1,
genType const & x); genType const & x);
@ -312,7 +315,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
typename genType::bool_type isnan(genType const & x); GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
/// Returns true if x holds a positive infinity or negative /// Returns true if x holds a positive infinity or negative
/// infinity representation in the underlying implementation's /// infinity representation in the underlying implementation's
@ -325,7 +328,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
typename genType::bool_type isinf(genType const & x); GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
/// Returns a signed integer value representing /// Returns a signed integer value representing
/// the encoding of a floating-point value. The floatingpoint /// the encoding of a floating-point value. The floatingpoint
@ -337,7 +340,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType> template <typename genType, typename genIType>
genIType floatBitsToInt(genType const & value); GLM_FUNC_DECL genIType floatBitsToInt(genType const & value);
/// Returns a unsigned integer value representing /// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint /// the encoding of a floating-point value. The floatingpoint
@ -349,7 +352,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genUType> template <typename genType, typename genUType>
genUType floatBitsToUint(genType const & value); GLM_FUNC_DECL genUType floatBitsToUint(genType const & value);
/// Returns a floating-point value corresponding to a signed /// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value. /// integer encoding of a floating-point value.
@ -365,7 +368,7 @@ namespace glm
/// ///
/// @todo Clarify this declaration, we don't need to actually specify the return type /// @todo Clarify this declaration, we don't need to actually specify the return type
template <typename genType, typename genIType> template <typename genType, typename genIType>
genType intBitsToFloat(genIType const & value); GLM_FUNC_DECL genType intBitsToFloat(genIType const & value);
/// Returns a floating-point value corresponding to a /// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value. /// unsigned integer encoding of a floating-point value.
@ -381,7 +384,7 @@ namespace glm
/// ///
/// @todo Clarify this declaration, we don't need to actually specify the return type /// @todo Clarify this declaration, we don't need to actually specify the return type
template <typename genType, typename genUType> template <typename genType, typename genUType>
genType uintBitsToFloat(genUType const & value); GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value);
/// Computes and returns a * b + c. /// Computes and returns a * b + c.
/// ///
@ -390,7 +393,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType> template <typename genType>
genType fma(genType const & a, genType const & b, genType const & c); GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
/// Splits x into a floating-point significand in the range /// Splits x into a floating-point significand in the range
/// [0.5, 1.0) and an integral exponent of two, such that: /// [0.5, 1.0) and an integral exponent of two, such that:
@ -407,7 +410,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType> template <typename genType, typename genIType>
genType frexp(genType const & x, genIType & exp); GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
/// Builds a floating-point number from x and the /// Builds a floating-point number from x and the
/// corresponding integral exponent of two in exp, returning: /// corresponding integral exponent of two in exp, returning:
@ -421,7 +424,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>;
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType> template <typename genType, typename genIType>
genType ldexp(genType const & x, genIType const & exp); GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
/// @} /// @}
}//namespace glm }//namespace glm

4
glm/core/func_common.inl
View File

@ -36,7 +36,7 @@ namespace detail
template <typename genFIType> template <typename genFIType>
struct Abs_<genFIType, true> struct Abs_<genFIType, true>
{ {
static genFIType get(genFIType const & x) GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
detail::type<genFIType>::is_float || detail::type<genFIType>::is_float ||
@ -49,7 +49,7 @@ namespace detail
template <typename genFIType> template <typename genFIType>
struct Abs_<genFIType, false> struct Abs_<genFIType, false>
{ {
static genFIType get(genFIType const & x) GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs"); detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs");

14
glm/core/func_exponential.hpp
View File

@ -50,7 +50,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType pow(genType const & base, genType const & exponent); GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
/// Returns the natural exponentiation of x, i.e., e^x. /// Returns the natural exponentiation of x, i.e., e^x.
/// ///
@ -60,7 +60,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType exp(genType const & x); GLM_FUNC_DECL genType exp(genType const & x);
/// Returns the natural logarithm of x, i.e., /// Returns the natural logarithm of x, i.e.,
/// returns the value y which satisfies the equation x = e^y. /// returns the value y which satisfies the equation x = e^y.
@ -72,7 +72,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType log(genType const & x); GLM_FUNC_DECL genType log(genType const & x);
/// Returns 2 raised to the x power. /// Returns 2 raised to the x power.
/// ///
@ -82,7 +82,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType exp2(genType const & x); GLM_FUNC_DECL genType exp2(genType const & x);
/// Returns the base 2 log of x, i.e., returns the value y, /// Returns the base 2 log of x, i.e., returns the value y,
/// which satisfies the equation x = 2 ^ y. /// which satisfies the equation x = 2 ^ y.
@ -93,7 +93,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType log2(genType const & x); GLM_FUNC_DECL genType log2(genType const & x);
/// Returns the positive square root of x. /// Returns the positive square root of x.
/// ///
@ -103,7 +103,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType sqrt(genType const & x); GLM_FUNC_DECL genType sqrt(genType const & x);
/// Returns the reciprocal of the positive square root of x. /// Returns the reciprocal of the positive square root of x.
/// ///
@ -113,7 +113,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType> template <typename genType>
genType inversesqrt(genType const & x); GLM_FUNC_DECL genType inversesqrt(genType const & x);
/// @} /// @}
}//namespace glm }//namespace glm

16
glm/core/func_geometric.hpp
View File

@ -48,7 +48,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length 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> /// @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 genType> template <typename genType>
typename genType::value_type length( GLM_FUNC_DECL typename genType::value_type length(
genType const & x); genType const & x);
/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). /// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
@ -58,7 +58,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance 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> /// @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 genType> template <typename genType>
typename genType::value_type distance( GLM_FUNC_DECL typename genType::value_type distance(
genType const & p0, genType const & p0,
genType const & p1); genType const & p1);
@ -69,7 +69,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot 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> /// @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 genType> template <typename genType>
typename genType::value_type dot( GLM_FUNC_DECL typename genType::value_type dot(
genType const & x, genType const & x,
genType const & y); genType const & y);
@ -80,7 +80,7 @@ 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/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> /// @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> template <typename T, precision P>
detail::tvec3<T, P> cross( GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y); detail::tvec3<T, P> const & y);
@ -89,7 +89,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize 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> /// @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 genType> template <typename genType>
genType normalize( GLM_FUNC_DECL genType normalize(
genType const & x); genType const & x);
/// If dot(Nref, I) < 0.0, return N, otherwise, return -N. /// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
@ -99,7 +99,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward 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> /// @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 genType> template <typename genType>
genType faceforward( GLM_FUNC_DECL genType faceforward(
genType const & N, genType const & N,
genType const & I, genType const & I,
genType const & Nref); genType const & Nref);
@ -112,7 +112,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect 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> /// @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 genType> template <typename genType>
genType reflect( GLM_FUNC_DECL genType reflect(
genType const & I, genType const & I,
genType const & N); genType const & N);
@ -125,7 +125,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract 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> /// @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 genType> template <typename genType>
genType refract( GLM_FUNC_DECL genType refract(
genType const & I, genType const & I,
genType const & N, genType const & N,
typename genType::value_type const & eta); typename genType::value_type const & eta);

50
glm/core/func_integer.hpp
View File

@ -52,9 +52,9 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType> template <typename genUType>
genUType uaddCarry( GLM_FUNC_DECL genUType uaddCarry(
genUType const & x, genUType const & x,
genUType const & y, genUType const & y,
genUType & carry); genUType & carry);
/// Subtracts the 32-bit unsigned integer y from x, returning /// Subtracts the 32-bit unsigned integer y from x, returning
@ -66,9 +66,9 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType> template <typename genUType>
genUType usubBorrow( GLM_FUNC_DECL genUType usubBorrow(
genUType const & x, genUType const & x,
genUType const & y, genUType const & y,
genUType & borrow); genUType & borrow);
/// Multiplies 32-bit integers x and y, producing a 64-bit /// Multiplies 32-bit integers x and y, producing a 64-bit
@ -80,10 +80,10 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType> template <typename genUType>
void umulExtended( GLM_FUNC_DECL void umulExtended(
genUType const & x, genUType const & x,
genUType const & y, genUType const & y,
genUType & msb, genUType & msb,
genUType & lsb); genUType & lsb);
/// Multiplies 32-bit integers x and y, producing a 64-bit /// Multiplies 32-bit integers x and y, producing a 64-bit
@ -95,10 +95,10 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIType> template <typename genIType>
void imulExtended( GLM_FUNC_DECL void imulExtended(
genIType const & x, genIType const & x,
genIType const & y, genIType const & y,
genIType & msb, genIType & msb,
genIType & lsb); genIType & lsb);
/// Extracts bits [offset, offset + bits - 1] from value, /// Extracts bits [offset, offset + bits - 1] from value,
@ -117,9 +117,9 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType> template <typename genIUType>
genIUType bitfieldExtract( GLM_FUNC_DECL genIUType bitfieldExtract(
genIUType const & Value, genIUType const & Value,
int const & Offset, int const & Offset,
int const & Bits); int const & Bits);
/// Returns the insertion the bits least-significant bits of insert into base. /// Returns the insertion the bits least-significant bits of insert into base.
@ -137,10 +137,10 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType> template <typename genIUType>
genIUType bitfieldInsert( GLM_FUNC_DECL genIUType bitfieldInsert(
genIUType const & Base, genIUType const & Base,
genIUType const & Insert, genIUType const & Insert,
int const & Offset, int const & Offset,
int const & Bits); int const & Bits);
/// Returns the reversal of the bits of value. /// Returns the reversal of the bits of value.
@ -152,7 +152,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType> template <typename genIUType>
genIUType bitfieldReverse(genIUType const & Value); GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
/// Returns the number of bits set to 1 in the binary representation of value. /// Returns the number of bits set to 1 in the binary representation of value.
/// ///
@ -163,7 +163,7 @@ namespace glm
/// ///
/// @todo Clarify the declaration to specify that scalars are suported. /// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType> template <typename T, template <typename> class genIUType>
typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value); GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
/// Returns the bit number of the least significant bit set to /// Returns the bit number of the least significant bit set to
/// 1 in the binary representation of value. /// 1 in the binary representation of value.
@ -176,7 +176,7 @@ namespace glm
/// ///
/// @todo Clarify the declaration to specify that scalars are suported. /// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType> template <typename T, template <typename> class genIUType>
typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value); GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
/// Returns the bit number of the most significant bit in the binary representation of value. /// Returns the bit number of the most significant bit in the binary representation of value.
/// For positive integers, the result will be the bit number of the most significant bit set to 1. /// For positive integers, the result will be the bit number of the most significant bit set to 1.
@ -190,7 +190,7 @@ namespace glm
/// ///
/// @todo Clarify the declaration to specify that scalars are suported. /// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType> template <typename T, template <typename> class genIUType>
typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value); GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
/// @} /// @}
}//namespace glm }//namespace glm

22
glm/core/func_matrix.hpp
View File

@ -52,8 +52,8 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType> template <typename matType>
matType matrixCompMult( GLM_FUNC_DECL matType matrixCompMult(
matType const & x, matType const & x,
matType const & y); matType const & y);
@ -68,8 +68,8 @@ namespace glm
/// ///
/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used. /// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
template <typename vecType, typename matType> template <typename vecType, typename matType>
matType outerProduct( GLM_FUNC_DECL matType outerProduct(
vecType const & c, vecType const & c,
vecType const & r); vecType const & r);
/// Returns the transposed matrix of x /// Returns the transposed matrix of x
@ -79,7 +79,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType> template <typename matType>
typename matType::transpose_type transpose( GLM_FUNC_DECL typename matType::transpose_type transpose(
matType const & x); matType const & x);
/// Return the determinant of a mat2 matrix. /// Return the determinant of a mat2 matrix.
@ -89,7 +89,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
typename detail::tmat2x2<T, P>::value_type determinant( GLM_FUNC_DECL typename detail::tmat2x2<T, P>::value_type determinant(
detail::tmat2x2<T, P> const & m); detail::tmat2x2<T, P> const & m);
/// Return the determinant of a mat3 matrix. /// Return the determinant of a mat3 matrix.
@ -99,7 +99,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
typename detail::tmat3x3<T, P>::value_type determinant( GLM_FUNC_DECL typename detail::tmat3x3<T, P>::value_type determinant(
detail::tmat3x3<T, P> const & m); detail::tmat3x3<T, P> const & m);
/// Return the determinant of a mat4 matrix. /// Return the determinant of a mat4 matrix.
@ -109,7 +109,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
typename detail::tmat4x4<T, P>::value_type determinant( GLM_FUNC_DECL typename detail::tmat4x4<T, P>::value_type determinant(
detail::tmat4x4<T, P> const & m); detail::tmat4x4<T, P> const & m);
/// Return the inverse of a mat2 matrix. /// Return the inverse of a mat2 matrix.
@ -119,7 +119,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
detail::tmat2x2<T, P> inverse( GLM_FUNC_DECL detail::tmat2x2<T, P> inverse(
detail::tmat2x2<T, P> const & m); detail::tmat2x2<T, P> const & m);
/// Return the inverse of a mat3 matrix. /// Return the inverse of a mat3 matrix.
@ -129,7 +129,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
detail::tmat3x3<T, P> inverse( GLM_FUNC_DECL detail::tmat3x3<T, P> inverse(
detail::tmat3x3<T, P> const & m); detail::tmat3x3<T, P> const & m);
/// Return the inverse of a mat4 matrix. /// Return the inverse of a mat4 matrix.
@ -139,7 +139,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P> template <typename T, precision P>
detail::tmat4x4<T, P> inverse( GLM_FUNC_DECL detail::tmat4x4<T, P> inverse(
detail::tmat4x4<T, P> const & m); detail::tmat4x4<T, P> const & m);
/// @} /// @}

8
glm/core/func_noise.hpp
View File

@ -50,7 +50,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 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> /// @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> template <typename genType>
typename genType::value_type noise1(genType const & x); GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
/// Returns a 2D noise value based on the input value x. /// Returns a 2D noise value based on the input value x.
/// ///
@ -59,7 +59,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/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> /// @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> template <typename genType>
detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x); GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
/// Returns a 3D noise value based on the input value x. /// Returns a 3D noise value based on the input value x.
/// ///
@ -68,7 +68,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/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> /// @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> template <typename genType>
detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x); GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
/// Returns a 4D noise value based on the input value x. /// Returns a 4D noise value based on the input value x.
/// ///
@ -77,7 +77,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/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> /// @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> template <typename genType>
detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x); GLM_FUNC_DECL detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
/// @} /// @}
}//namespace glm }//namespace glm

24
glm/core/func_packing.hpp
View File

@ -52,7 +52,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uint32 packUnorm2x16(vec2 const & v); GLM_FUNC_DECL uint32 packUnorm2x16(vec2 const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer. //! Then, the results are packed into the returned 32-bit unsigned integer.
@ -65,7 +65,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uint32 packSnorm2x16(vec2 const & v); GLM_FUNC_DECL uint32 packSnorm2x16(vec2 const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer. //! Then, the results are packed into the returned 32-bit unsigned integer.
@ -78,7 +78,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uint32 packUnorm4x8(vec4 const & v); GLM_FUNC_DECL uint32 packUnorm4x8(vec4 const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer. //! Then, the results are packed into the returned 32-bit unsigned integer.
@ -91,7 +91,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uint32 packSnorm4x8(vec4 const & v); GLM_FUNC_DECL uint32 packSnorm4x8(vec4 const & v);
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@ -104,7 +104,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
vec2 unpackUnorm2x16(uint32 const & p); GLM_FUNC_DECL vec2 unpackUnorm2x16(uint32 const & p);
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@ -117,7 +117,7 @@ namespace glm
//! //!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
vec2 unpackSnorm2x16(uint32 const & p); GLM_FUNC_DECL vec2 unpackSnorm2x16(uint32 const & p);
/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@ -130,7 +130,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
vec4 unpackUnorm4x8(uint32 const & p); GLM_FUNC_DECL vec4 unpackUnorm4x8(uint32 const & p);
/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@ -143,7 +143,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
vec4 unpackSnorm4x8(uint32 const & p); GLM_FUNC_DECL vec4 unpackSnorm4x8(uint32 const & p);
/// Returns a double-precision value obtained by packing the components of v into a 64-bit value. /// Returns a double-precision value obtained by packing the components of v into a 64-bit value.
/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. /// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified.
@ -153,7 +153,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
double packDouble2x32(uvec2 const & v); GLM_FUNC_DECL double packDouble2x32(uvec2 const & v);
/// Returns a two-component unsigned integer vector representation of v. /// Returns a two-component unsigned integer vector representation of v.
/// The bit-level representation of v is preserved. /// The bit-level representation of v is preserved.
@ -162,7 +162,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uvec2 unpackDouble2x32(double const & v); GLM_FUNC_DECL uvec2 unpackDouble2x32(double const & v);
/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector /// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector
/// to the 16-bit floating-point representation found in the OpenGL Specification, /// to the 16-bit floating-point representation found in the OpenGL Specification,
@ -172,7 +172,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
uint packHalf2x16(vec2 const & v); GLM_FUNC_DECL uint32 packHalf2x16(vec2 const & v);
/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, /// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values,
/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
@ -182,7 +182,7 @@ namespace glm
/// ///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
vec2 unpackHalf2x16(uint32 const & v); GLM_FUNC_DECL vec2 unpackHalf2x16(uint32 const & v);
/// @} /// @}
}//namespace glm }//namespace glm

30
glm/core/func_trigonometric.hpp
View File

@ -52,7 +52,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType radians(genType const & degrees); GLM_FUNC_DECL genType radians(genType const & degrees);
/// Converts radians to degrees and returns the result. /// Converts radians to degrees and returns the result.
/// ///
@ -61,7 +61,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType degrees(genType const & radians); GLM_FUNC_DECL genType degrees(genType const & radians);
/// The standard trigonometric sine function. /// The standard trigonometric sine function.
/// The values returned by this function will range from [-1, 1]. /// The values returned by this function will range from [-1, 1].
@ -71,7 +71,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType sin(genType const & angle); GLM_FUNC_DECL genType sin(genType const & angle);
/// The standard trigonometric cosine function. /// The standard trigonometric cosine function.
/// The values returned by this function will range from [-1, 1]. /// The values returned by this function will range from [-1, 1].
@ -81,7 +81,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType cos(genType const & angle); GLM_FUNC_DECL genType cos(genType const & angle);
/// The standard trigonometric tangent function. /// The standard trigonometric tangent function.
/// ///
@ -90,7 +90,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType tan(genType const & angle); GLM_FUNC_DECL genType tan(genType const & angle);
/// Arc sine. Returns an angle whose sine is x. /// Arc sine. Returns an angle whose sine is x.
/// The range of values returned by this function is [-PI/2, PI/2]. /// The range of values returned by this function is [-PI/2, PI/2].
@ -101,7 +101,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType asin(genType const & x); GLM_FUNC_DECL genType asin(genType const & x);
/// Arc cosine. Returns an angle whose sine is x. /// Arc cosine. Returns an angle whose sine is x.
/// The range of values returned by this function is [0, PI]. /// The range of values returned by this function is [0, PI].
@ -112,7 +112,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType acos(genType const & x); GLM_FUNC_DECL genType acos(genType const & x);
/// Arc tangent. Returns an angle whose tangent is y/x. /// Arc tangent. Returns an angle whose tangent is y/x.
/// The signs of x and y are used to determine what /// The signs of x and y are used to determine what
@ -125,7 +125,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType atan(genType const & y, genType const & x); GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
/// Arc tangent. Returns an angle whose tangent is y_over_x. /// Arc tangent. Returns an angle whose tangent is y_over_x.
/// The range of values returned by this function is [-PI/2, PI/2]. /// The range of values returned by this function is [-PI/2, PI/2].
@ -135,7 +135,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType atan(genType const & y_over_x); GLM_FUNC_DECL genType atan(genType const & y_over_x);
/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2 /// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
/// ///
@ -144,7 +144,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType sinh(genType const & angle); GLM_FUNC_DECL genType sinh(genType const & angle);
/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2 /// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
/// ///
@ -153,7 +153,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType cosh(genType const & angle); GLM_FUNC_DECL genType cosh(genType const & angle);
/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle) /// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
/// ///
@ -162,7 +162,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType tanh(genType const & angle); GLM_FUNC_DECL genType tanh(genType const & angle);
/// Arc hyperbolic sine; returns the inverse of sinh. /// Arc hyperbolic sine; returns the inverse of sinh.
/// ///
@ -171,7 +171,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType asinh(genType const & x); GLM_FUNC_DECL genType asinh(genType const & x);
/// Arc hyperbolic cosine; returns the non-negative inverse /// Arc hyperbolic cosine; returns the non-negative inverse
/// of cosh. Results are undefined if x < 1. /// of cosh. Results are undefined if x < 1.
@ -181,7 +181,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType acosh(genType const & x); GLM_FUNC_DECL genType acosh(genType const & x);
/// Arc hyperbolic tangent; returns the inverse of tanh. /// Arc hyperbolic tangent; returns the inverse of tanh.
/// Results are undefined if abs(x) >= 1. /// Results are undefined if abs(x) >= 1.
@ -191,7 +191,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType> template <typename genType>
genType atanh(genType const & x); GLM_FUNC_DECL genType atanh(genType const & x);
/// @} /// @}
}//namespace glm }//namespace glm

18
glm/core/func_vector_relational.hpp
View File

@ -53,7 +53,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns the component-wise comparison of result x <= y. /// Returns the component-wise comparison of result x <= y.
/// ///
@ -62,7 +62,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns the component-wise comparison of result x > y. /// Returns the component-wise comparison of result x > y.
/// ///
@ -71,7 +71,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns the component-wise comparison of result x >= y. /// Returns the component-wise comparison of result x >= y.
/// ///
@ -80,7 +80,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns the component-wise comparison of result x == y. /// Returns the component-wise comparison of result x == y.
/// ///
@ -89,7 +89,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns the component-wise comparison of result x != y. /// Returns the component-wise comparison of result x != y.
/// ///
@ -98,7 +98,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y); GLM_FUNC_DECL typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
/// Returns true if any component of x is true. /// Returns true if any component of x is true.
/// ///
@ -107,7 +107,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <precision P, template <typename, precision> class vecType> template <precision P, template <typename, precision> class vecType>
bool any(vecType<bool, P> const & v); GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
/// Returns true if all components of x are true. /// Returns true if all components of x are true.
/// ///
@ -116,7 +116,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <precision P, template <typename, precision> class vecType> template <precision P, template <typename, precision> class vecType>
bool all(vecType<bool, P> const & v); GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
/// Returns the component-wise logical complement of x. /// Returns the component-wise logical complement of x.
/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead. /// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
@ -126,7 +126,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <precision P, template <typename, precision> class vecType> template <precision P, template <typename, precision> class vecType>
vecType<bool, P> not_(vecType<bool, P> const & v); GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
/// @} /// @}
}//namespace glm }//namespace glm

52
glm/core/type_mat2x2.hpp
View File

@ -146,101 +146,101 @@ namespace detail
}; };
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator+ ( GLM_FUNC_DECL tmat2x2<T, P> operator+ (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::value_type const & s); typename tmat2x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator+ ( GLM_FUNC_DECL tmat2x2<T, P> operator+ (
typename tmat2x2<T, P>::value_type const & s, typename tmat2x2<T, P>::value_type const & s,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator+ ( GLM_FUNC_DECL tmat2x2<T, P> operator+ (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator- ( GLM_FUNC_DECL tmat2x2<T, P> operator- (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::value_type const & s); typename tmat2x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator- ( GLM_FUNC_DECL tmat2x2<T, P> operator- (
typename tmat2x2<T, P>::value_type const & s, typename tmat2x2<T, P>::value_type const & s,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator- ( GLM_FUNC_DECL tmat2x2<T, P> operator- (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator* ( GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::value_type const & s); typename tmat2x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator* ( GLM_FUNC_DECL tmat2x2<T, P> operator* (
typename tmat2x2<T, P>::value_type const & s, typename tmat2x2<T, P>::value_type const & s,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x2<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator* (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::row_type const & v); typename tmat2x2<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x2<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator* (
typename tmat2x2<T, P>::col_type const & v, typename tmat2x2<T, P>::col_type const & v,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator* ( GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator* ( GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat3x2<T, P> const & m2); tmat3x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator* ( GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat4x2<T, P> const & m2); tmat4x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator/ ( GLM_FUNC_DECL tmat2x2<T, P> operator/ (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::value_type const & s); typename tmat2x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator/ ( GLM_FUNC_DECL tmat2x2<T, P> operator/ (
typename tmat2x2<T, P>::value_type const & s, typename tmat2x2<T, P>::value_type const & s,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x2<T, P>::col_type operator/ ( GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/ (
tmat2x2<T, P> const & m, tmat2x2<T, P> const & m,
typename tmat2x2<T, P>::row_type const & v); typename tmat2x2<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x2<T, P>::row_type operator/ ( GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/ (
typename tmat2x2<T, P>::col_type const & v, typename tmat2x2<T, P>::col_type const & v,
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator/ ( GLM_FUNC_DECL tmat2x2<T, P> operator/ (
tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> const operator-( GLM_FUNC_DECL tmat2x2<T, P> const operator-(
tmat2x2<T, P> const & m); tmat2x2<T, P> const & m);
} //namespace detail } //namespace detail
} //namespace glm } //namespace glm

31
glm/core/type_mat2x3.hpp
View File

@ -102,8 +102,8 @@ namespace detail
GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);
// Accesses // Accesses
col_type & operator[](size_type i); GLM_FUNC_DECL col_type & operator[](size_type i);
col_type const & operator[](size_type i) const; GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators // Unary updatable operators
GLM_FUNC_DECL tmat2x3<T, P> & operator= (tmat2x3<T, P> const & m); GLM_FUNC_DECL tmat2x3<T, P> & operator= (tmat2x3<T, P> const & m);
@ -134,8 +134,9 @@ namespace detail
}; };
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator+ ( GLM_FUNC_DECL tmat2x3<T, P> operator+ (
tmat2x3<T, P> const & m, tmat2x3<T, P> const & m,
typename tmat2x3<T, P>::value_type const & s); typename tmat2x3<T, P>::value_type const & s);
@ -145,63 +146,63 @@ namespace detail
tmat2x3<T, P> const & m2); tmat2x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator- ( GLM_FUNC_DECL tmat2x3<T, P> operator- (
tmat2x3<T, P> const & m, tmat2x3<T, P> const & m,
typename tmat2x3<T, P>::value_type const & s); typename tmat2x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator- ( GLM_FUNC_DECL tmat2x3<T, P> operator- (
tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m1,
tmat2x3<T, P> const & m2); tmat2x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> const & m, tmat2x3<T, P> const & m,
typename tmat2x3<T, P>::value_type const & s); typename tmat2x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
typename tmat2x3<T, P>::value_type const & s, typename tmat2x3<T, P>::value_type const & s,
tmat2x3<T, P> const & m); tmat2x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x3<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator* (
tmat2x3<T, P> const & m, tmat2x3<T, P> const & m,
typename tmat2x3<T, P>::row_type const & v); typename tmat2x3<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x3<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator* (
typename tmat2x3<T, P>::col_type const & v, typename tmat2x3<T, P>::col_type const & v,
tmat2x3<T, P> const & m); tmat2x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator* ( GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m1,
tmat3x2<T, P> const & m2); tmat3x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator* ( GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m1,
tmat4x2<T, P> const & m2); tmat4x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator/ ( GLM_FUNC_DECL tmat2x3<T, P> operator/ (
tmat2x3<T, P> const & m, tmat2x3<T, P> const & m,
typename tmat2x3<T, P>::value_type const & s); typename tmat2x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator/ ( GLM_FUNC_DECL tmat2x3<T, P> operator/ (
typename tmat2x3<T, P>::value_type const & s, typename tmat2x3<T, P>::value_type const & s,
tmat2x3<T, P> const & m); tmat2x3<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> const operator- ( GLM_FUNC_DECL tmat2x3<T, P> const operator- (
tmat2x3<T, P> const & m); tmat2x3<T, P> const & m);
}//namespace detail }//namespace detail

63
glm/core/type_mat2x4.hpp
View File

@ -136,74 +136,75 @@ namespace detail
}; };
// Binary operators // Binary operators
template <typename T, precision P>
tmat2x4<T, P> operator+ (
tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator+ ( GLM_FUNC_DECL tmat2x4<T, P> operator+ (
tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P>
tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
tmat2x4<T, P> operator* (
tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s); typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator* ( GLM_FUNC_DECL tmat2x4<T, P> operator+ (
tmat2x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
typename tmat2x4<T, P>::value_type const & s, typename tmat2x4<T, P>::value_type const & s,
tmat2x4<T, P> const & m); tmat2x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x4<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator* (
tmat2x4<T, P> const & m, tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::row_type const & v); typename tmat2x4<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat2x4<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator* (
typename tmat2x4<T, P>::col_type const & v, typename tmat2x4<T, P>::col_type const & v,
tmat2x4<T, P> const & m); tmat2x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator* ( GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m1,
tmat4x2<T, P> const & m2); tmat4x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator* ( GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m1,
tmat2x2<T, P> const & m2); tmat2x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator* ( GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m1,
tmat3x2<T, P> const & m2); tmat3x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator/ ( GLM_FUNC_DECL tmat2x4<T, P> operator/ (
tmat2x4<T, P> const & m, tmat2x4<T, P> const & m,
typename tmat2x4<T, P>::value_type const & s); typename tmat2x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator/ ( GLM_FUNC_DECL tmat2x4<T, P> operator/ (
typename tmat2x4<T, P>::value_type const & s, typename tmat2x4<T, P>::value_type const & s,
tmat2x4<T, P> const & m); tmat2x4<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> const operator- ( GLM_FUNC_DECL tmat2x4<T, P> const operator- (
tmat2x4<T, P> const & m); tmat2x4<T, P> const & m);
}//namespace detail }//namespace detail

34
glm/core/type_mat3x2.hpp
View File

@ -79,12 +79,10 @@ namespace detail
GLM_FUNC_DECL explicit tmat3x2( GLM_FUNC_DECL explicit tmat3x2(
U const & x); U const & x);
template template<
<
typename X1, typename Y1, typename X1, typename Y1,
typename X2, typename Y2, typename X2, typename Y2,
typename X3, typename Y3 typename X3, typename Y3>
>
GLM_FUNC_DECL explicit tmat3x2( GLM_FUNC_DECL explicit tmat3x2(
X1 const & x1, Y1 const & y1, X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2, X2 const & x2, Y2 const & y2,
@ -143,73 +141,73 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator+ ( GLM_FUNC_DECL tmat3x2<T, P> operator+ (
tmat3x2<T, P> const & m, tmat3x2<T, P> const & m,
typename tmat3x2<T, P>::value_type const & s); typename tmat3x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator+ ( GLM_FUNC_DECL tmat3x2<T, P> operator+ (
tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m1,
tmat3x2<T, P> const & m2); tmat3x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator- ( GLM_FUNC_DECL tmat3x2<T, P> operator- (
tmat3x2<T, P> const & m, tmat3x2<T, P> const & m,
typename tmat3x2<T, P>::value_type const & s); typename tmat3x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator- ( GLM_FUNC_DECL tmat3x2<T, P> operator- (
tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m1,
tmat3x2<T, P> const & m2); tmat3x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator* ( GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> const & m, tmat3x2<T, P> const & m,
typename tmat3x2<T, P>::value_type const & s); typename tmat3x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator* ( GLM_FUNC_DECL tmat3x2<T, P> operator* (
typename tmat3x2<T, P>::value_type const & s, typename tmat3x2<T, P>::value_type const & s,
tmat3x2<T, P> const & m); tmat3x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x2<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat3x2<T, P>::col_type operator* (
tmat3x2<T, P> const & m, tmat3x2<T, P> const & m,
typename tmat3x2<T, P>::row_type const & v); typename tmat3x2<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x2<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat3x2<T, P>::row_type operator* (
typename tmat3x2<T, P>::col_type const & v, typename tmat3x2<T, P>::col_type const & v,
tmat3x2<T, P> const & m); tmat3x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x2<T, P> operator* ( GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m1,
tmat2x3<T, P> const & m2); tmat2x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator* ( GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator* ( GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m1,
tmat4x3<T, P> const & m2); tmat4x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator/ ( GLM_FUNC_DECL tmat3x2<T, P> operator/ (
tmat3x2<T, P> const & m, tmat3x2<T, P> const & m,
typename tmat3x2<T, P>::value_type const & s); typename tmat3x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator/ ( GLM_FUNC_DECL tmat3x2<T, P> operator/ (
typename tmat3x2<T, P>::value_type const & s, typename tmat3x2<T, P>::value_type const & s,
tmat3x2<T, P> const & m); tmat3x2<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> const operator-( GLM_FUNC_DECL tmat3x2<T, P> const operator-(
tmat3x2<T, P> const & m); tmat3x2<T, P> const & m);
}//namespace detail }//namespace detail

50
glm/core/type_mat3x3.hpp
View File

@ -85,12 +85,10 @@ namespace detail
GLM_FUNC_DECL explicit tmat3x3( GLM_FUNC_DECL explicit tmat3x3(
U const & x); U const & x);
template template<
<
typename X1, typename Y1, typename Z1, typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2, typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3 typename X3, typename Y3, typename Z3>
>
GLM_FUNC_DECL explicit tmat3x3( GLM_FUNC_DECL explicit tmat3x3(
X1 const & x1, Y1 const & y1, Z1 const & z1, X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2, X2 const & x2, Y2 const & y2, Z2 const & z2,
@ -151,98 +149,98 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator+ ( GLM_FUNC_DECL tmat3x3<T, P> operator+ (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::value_type const & s); typename tmat3x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator+ ( GLM_FUNC_DECL tmat3x3<T, P> operator+ (
typename tmat3x3<T, P>::value_type const & s, typename tmat3x3<T, P>::value_type const & s,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator+ ( GLM_FUNC_DECL tmat3x3<T, P> operator+ (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator- ( GLM_FUNC_DECL tmat3x3<T, P> operator- (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::value_type const & s); typename tmat3x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator- ( GLM_FUNC_DECL tmat3x3<T, P> operator- (
typename tmat3x3<T, P>::value_type const & s, typename tmat3x3<T, P>::value_type const & s,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator- ( GLM_FUNC_DECL tmat3x3<T, P> operator- (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator* ( GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::value_type const & s); typename tmat3x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator* ( GLM_FUNC_DECL tmat3x3<T, P> operator* (
typename tmat3x3<T, P>::value_type const & s, typename tmat3x3<T, P>::value_type const & s,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x3<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator* (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::row_type const & v); typename tmat3x3<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x3<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator* (
typename tmat3x3<T, P>::col_type const & v, typename tmat3x3<T, P>::col_type const & v,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator* ( GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat2x3<T, P> const & m2); tmat2x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator* ( GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat4x3<T, P> const & m2); tmat4x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator/ ( GLM_FUNC_DECL tmat3x3<T, P> operator/ (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::value_type const & s); typename tmat3x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator/ ( GLM_FUNC_DECL tmat3x3<T, P> operator/ (
typename tmat3x3<T, P>::value_type const & s, typename tmat3x3<T, P>::value_type const & s,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x3<T, P>::col_type operator/ ( GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator/ (
tmat3x3<T, P> const & m, tmat3x3<T, P> const & m,
typename tmat3x3<T, P>::row_type const & v); typename tmat3x3<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x3<T, P>::row_type operator/ ( GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator/ (
typename tmat3x3<T, P>::col_type const & v, typename tmat3x3<T, P>::col_type const & v,
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator/ ( GLM_FUNC_DECL tmat3x3<T, P> operator/ (
tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> const operator-( GLM_FUNC_DECL tmat3x3<T, P> const operator-(
tmat3x3<T, P> const & m); tmat3x3<T, P> const & m);
}//namespace detail }//namespace detail

38
glm/core/type_mat3x4.hpp
View File

@ -79,12 +79,10 @@ namespace detail
GLM_FUNC_DECL explicit tmat3x4( GLM_FUNC_DECL explicit tmat3x4(
U const & x); U const & x);
template template<
<
typename X1, typename Y1, typename Z1, typename W1, typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2, typename X2, typename Y2, typename Z2, typename W2,
typename X3, typename Y3, typename Z3, typename W3 typename X3, typename Y3, typename Z3, typename W3>
>
GLM_FUNC_DECL explicit tmat3x4( GLM_FUNC_DECL explicit tmat3x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
@ -110,8 +108,8 @@ namespace detail
GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x); GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x);
// Accesses // Accesses
col_type & operator[](size_type i); GLM_FUNC_DECL col_type & operator[](size_type i);
col_type const & operator[](size_type i) const; GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators // Unary updatable operators
GLM_FUNC_DECL tmat3x4<T, P> & operator= (tmat3x4<T, P> const & m); GLM_FUNC_DECL tmat3x4<T, P> & operator= (tmat3x4<T, P> const & m);
@ -143,73 +141,73 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator+ ( GLM_FUNC_DECL tmat3x4<T, P> operator+ (
tmat3x4<T, P> const & m, tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s); typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator+ ( GLM_FUNC_DECL tmat3x4<T, P> operator+ (
tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m1,
tmat3x4<T, P> const & m2); tmat3x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator- ( GLM_FUNC_DECL tmat3x4<T, P> operator- (
tmat3x4<T, P> const & m, tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s); typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator- ( GLM_FUNC_DECL tmat3x4<T, P> operator- (
tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m1,
tmat3x4<T, P> const & m2); tmat3x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator* ( GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m, tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s); typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator* ( GLM_FUNC_DECL tmat3x4<T, P> operator* (
typename tmat3x4<T, P>::value_type const & s, typename tmat3x4<T, P>::value_type const & s,
tmat3x4<T, P> const & m); tmat3x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x4<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat3x4<T, P>::col_type operator* (
tmat3x4<T, P> const & m, tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::row_type const & v); typename tmat3x4<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat3x4<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat3x4<T, P>::row_type operator* (
typename tmat3x4<T, P>::col_type const & v, typename tmat3x4<T, P>::col_type const & v,
tmat3x4<T, P> const & m); tmat3x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator* ( GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m1,
tmat4x3<T, P> const & m2); tmat4x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator* ( GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m1,
tmat2x3<T, P> const & m2); tmat2x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator* ( GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m1,
tmat3x3<T, P> const & m2); tmat3x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator/ ( GLM_FUNC_DECL tmat3x4<T, P> operator/ (
tmat3x4<T, P> const & m, tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s); typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator/ ( GLM_FUNC_DECL tmat3x4<T, P> operator/ (
typename tmat3x4<T, P>::value_type const & s, typename tmat3x4<T, P>::value_type const & s,
tmat3x4<T, P> const & m); tmat3x4<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> const operator-( GLM_FUNC_DECL tmat3x4<T, P> const operator-(
tmat3x4<T, P> const & m); tmat3x4<T, P> const & m);
}//namespace detail }//namespace detail

40
glm/core/type_mat4x2.hpp
View File

@ -81,13 +81,11 @@ namespace detail
GLM_FUNC_DECL explicit tmat4x2( GLM_FUNC_DECL explicit tmat4x2(
U const & x); U const & x);
template template<
< typename X1, typename Y1,
typename X1, typename Y1, typename X2, typename Y2,
typename X2, typename Y2,
typename X3, typename Y3, typename X3, typename Y3,
typename X4, typename Y4 typename X4, typename Y4>
>
GLM_FUNC_DECL explicit tmat4x2( GLM_FUNC_DECL explicit tmat4x2(
X1 const & x1, Y1 const & y1, X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2, X2 const & x2, Y2 const & y2,
@ -148,75 +146,75 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator+ ( GLM_FUNC_DECL tmat4x2<T, P> operator+ (
tmat4x2<T, P> const & m, tmat4x2<T, P> const & m,
typename tmat4x2<T, P>::value_type const & s); typename tmat4x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator+ ( GLM_FUNC_DECL tmat4x2<T, P> operator+ (
tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m1,
tmat4x2<T, P> const & m2); tmat4x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator- ( GLM_FUNC_DECL tmat4x2<T, P> operator- (
tmat4x2<T, P> const & m, tmat4x2<T, P> const & m,
typename tmat4x2<T, P>::value_type const & s); typename tmat4x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator- ( GLM_FUNC_DECL tmat4x2<T, P> operator- (
tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m1,
tmat4x2<T, P> const & m2); tmat4x2<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator* ( GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> const & m, tmat4x2<T, P> const & m,
typename tmat4x2<T, P>::value_type const & s); typename tmat4x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator* ( GLM_FUNC_DECL tmat4x2<T, P> operator* (
typename tmat4x2<T, P>::value_type const & s, typename tmat4x2<T, P>::value_type const & s,
tmat4x2<T, P> const & m); tmat4x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x2<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat4x2<T, P>::col_type operator* (
tmat4x2<T, P> const & m, tmat4x2<T, P> const & m,
typename tmat4x2<T, P>::row_type const & v); typename tmat4x2<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x2<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat4x2<T, P>::row_type operator* (
typename tmat4x2<T, P>::col_type const & v, typename tmat4x2<T, P>::col_type const & v,
tmat4x2<T, P> const & m); tmat4x2<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat3x2<T, P> operator* ( GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m1,
tmat3x4<T, P> const & m2); tmat3x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator* ( GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat2x4<T, P> const & m2); tmat2x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator/ ( GLM_FUNC_DECL tmat4x2<T, P> operator/ (
tmat4x2<T, P> const & m, tmat4x2<T, P> const & m,
typename tmat4x2<T, P>::value_type const & s); typename tmat4x2<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> operator/ ( GLM_FUNC_DECL tmat4x2<T, P> operator/ (
typename tmat4x2<T, P>::value_type const & s, typename tmat4x2<T, P>::value_type const & s,
tmat4x2<T, P> const & m); tmat4x2<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat4x2<T, P> const operator-( GLM_FUNC_DECL tmat4x2<T, P> const operator-(
tmat4x2<T, P> const & m); tmat4x2<T, P> const & m);
}//namespace detail }//namespace detail
}//namespace glm }//namespace glm

32
glm/core/type_mat4x3.hpp
View File

@ -113,8 +113,8 @@ namespace detail
GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x); GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x);
// Accesses // Accesses
col_type & operator[](size_type i); GLM_FUNC_DECL col_type & operator[](size_type i);
col_type const & operator[](size_type i) const; GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators // Unary updatable operators
GLM_FUNC_DECL tmat4x3<T, P> & operator= (tmat4x3<T, P> const & m); GLM_FUNC_DECL tmat4x3<T, P> & operator= (tmat4x3<T, P> const & m);
@ -146,73 +146,73 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator+ ( GLM_FUNC_DECL tmat4x3<T, P> operator+ (
tmat4x3<T, P> const & m, tmat4x3<T, P> const & m,
typename tmat4x3<T, P>::value_type const & s); typename tmat4x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator+ ( GLM_FUNC_DECL tmat4x3<T, P> operator+ (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat4x3<T, P> const & m2); tmat4x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator- ( GLM_FUNC_DECL tmat4x3<T, P> operator- (
tmat4x3<T, P> const & m, tmat4x3<T, P> const & m,
typename tmat4x3<T, P>::value_type const & s); typename tmat4x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator- ( GLM_FUNC_DECL tmat4x3<T, P> operator- (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat4x3<T, P> const & m2); tmat4x3<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator* ( GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> const & m, tmat4x3<T, P> const & m,
typename tmat4x3<T, P>::value_type const & s); typename tmat4x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator* ( GLM_FUNC_DECL tmat4x3<T, P> operator* (
typename tmat4x3<T, P>::value_type const & s, typename tmat4x3<T, P>::value_type const & s,
tmat4x3<T, P> const & m); tmat4x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x3<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat4x3<T, P>::col_type operator* (
tmat4x3<T, P> const & m, tmat4x3<T, P> const & m,
typename tmat4x3<T, P>::row_type const & v); typename tmat4x3<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x3<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat4x3<T, P>::row_type operator* (
typename tmat4x3<T, P>::col_type const & v, typename tmat4x3<T, P>::col_type const & v,
tmat4x3<T, P> const & m); tmat4x3<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x3<T, P> operator* ( GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat2x4<T, P> const & m2); tmat2x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x3<T, P> operator* ( GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat3x4<T, P> const & m2); tmat3x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator* ( GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator/ ( GLM_FUNC_DECL tmat4x3<T, P> operator/ (
tmat4x3<T, P> const & m, tmat4x3<T, P> const & m,
typename tmat4x3<T, P>::value_type const & s); typename tmat4x3<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> operator/ ( GLM_FUNC_DECL tmat4x3<T, P> operator/ (
typename tmat4x3<T, P>::value_type const & s, typename tmat4x3<T, P>::value_type const & s,
tmat4x3<T, P> const & m); tmat4x3<T, P> const & m);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat4x3<T, P> const operator- ( GLM_FUNC_DECL tmat4x3<T, P> const operator- (
tmat4x3<T, P> const & m); tmat4x3<T, P> const & m);
}//namespace detail }//namespace detail

38
glm/core/type_mat4x4.hpp
View File

@ -154,98 +154,98 @@ namespace detail
// Binary operators // Binary operators
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator+ ( GLM_FUNC_DECL tmat4x4<T, P> operator+ (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::value_type const & s); typename tmat4x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator+ ( GLM_FUNC_DECL tmat4x4<T, P> operator+ (
typename tmat4x4<T, P>::value_type const & s, typename tmat4x4<T, P>::value_type const & s,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator+ ( GLM_FUNC_DECL tmat4x4<T, P> operator+ (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator- ( GLM_FUNC_DECL tmat4x4<T, P> operator- (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::value_type const & s); typename tmat4x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator- ( GLM_FUNC_DECL tmat4x4<T, P> operator- (
typename tmat4x4<T, P>::value_type const & s, typename tmat4x4<T, P>::value_type const & s,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator- ( GLM_FUNC_DECL tmat4x4<T, P> operator- (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator* ( GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::value_type const & s); typename tmat4x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator* ( GLM_FUNC_DECL tmat4x4<T, P> operator* (
typename tmat4x4<T, P>::value_type const & s, typename tmat4x4<T, P>::value_type const & s,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x4<T, P>::col_type operator* ( GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator* (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::row_type const & v); typename tmat4x4<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x4<T, P>::row_type operator* ( GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator* (
typename tmat4x4<T, P>::col_type const & v, typename tmat4x4<T, P>::col_type const & v,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat2x4<T, P> operator* ( GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat2x4<T, P> const & m2); tmat2x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat3x4<T, P> operator* ( GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat3x4<T, P> const & m2); tmat3x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator* ( GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator/ ( GLM_FUNC_DECL tmat4x4<T, P> operator/ (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::value_type const & s); typename tmat4x4<T, P>::value_type const & s);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator/ ( GLM_FUNC_DECL tmat4x4<T, P> operator/ (
typename tmat4x4<T, P>::value_type const & s, typename tmat4x4<T, P>::value_type const & s,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x4<T, P>::col_type operator/ ( GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator/ (
tmat4x4<T, P> const & m, tmat4x4<T, P> const & m,
typename tmat4x4<T, P>::row_type const & v); typename tmat4x4<T, P>::row_type const & v);
template <typename T, precision P> template <typename T, precision P>
typename tmat4x4<T, P>::row_type operator/ ( GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator/ (
typename tmat4x4<T, P>::col_type & v, typename tmat4x4<T, P>::col_type & v,
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> operator/ ( GLM_FUNC_DECL tmat4x4<T, P> operator/ (
tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2); tmat4x4<T, P> const & m2);
// Unary constant operators // Unary constant operators
template <typename T, precision P> template <typename T, precision P>
tmat4x4<T, P> const operator- ( GLM_FUNC_DECL tmat4x4<T, P> const operator- (
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
}//namespace detail }//namespace detail

2
glm/core/type_vec2.hpp
View File

@ -115,7 +115,7 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors
tvec2(tref2<T, P> const & r); GLM_FUNC_DECL tvec2(tref2<T, P> const & r);
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that) GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)

2
glm/core/type_vec4.inl
View File

@ -1140,7 +1140,7 @@ namespace detail
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator| GLM_FUNC_QUALIFIER tvec4<T, P> operator|
( (
tvec4<T, P> const & v1, tvec4<T, P> const & v1,
tvec4<T, P> const & v2 tvec4<T, P> const & v2
) )
{ {

50
glm/gtc/constants.hpp
View File

@ -56,127 +56,127 @@ namespace glm
/// @todo Implement epsilon for half-precision floating point type. /// @todo Implement epsilon for half-precision floating point type.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType epsilon(); GLM_FUNC_DECL genType epsilon();
/// Return 0. /// Return 0.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType zero(); GLM_FUNC_DECL genType zero();
/// Return 1. /// Return 1.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType one(); GLM_FUNC_DECL genType one();
/// Return the pi constant. /// Return the pi constant.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType pi(); GLM_FUNC_DECL genType pi();
/// Return square root of pi. /// Return square root of pi.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_pi(); GLM_FUNC_DECL genType root_pi();
/// Return pi / 2. /// Return pi / 2.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType half_pi(); GLM_FUNC_DECL genType half_pi();
/// Return pi / 4. /// Return pi / 4.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType quarter_pi(); GLM_FUNC_DECL genType quarter_pi();
/// Return 1 / pi. /// Return 1 / pi.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType one_over_pi(); GLM_FUNC_DECL genType one_over_pi();
/// Return 2 / pi. /// Return 2 / pi.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType two_over_pi(); GLM_FUNC_DECL genType two_over_pi();
/// Return 2 / sqrt(pi). /// Return 2 / sqrt(pi).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType two_over_root_pi(); GLM_FUNC_DECL genType two_over_root_pi();
/// Return 1 / sqrt(2). /// Return 1 / sqrt(2).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType one_over_root_two(); GLM_FUNC_DECL genType one_over_root_two();
/// Return sqrt(pi / 2). /// Return sqrt(pi / 2).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_half_pi(); GLM_FUNC_DECL genType root_half_pi();
/// Return sqrt(2 * pi). /// Return sqrt(2 * pi).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_two_pi(); GLM_FUNC_DECL genType root_two_pi();
/// Return sqrt(ln(4)). /// Return sqrt(ln(4)).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_ln_four(); GLM_FUNC_DECL genType root_ln_four();
/// Return e constant. /// Return e constant.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType e(); GLM_FUNC_DECL genType e();
/// Return Euler's constant. /// Return Euler's constant.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType euler(); GLM_FUNC_DECL genType euler();
/// Return sqrt(2). /// Return sqrt(2).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_two(); GLM_FUNC_DECL genType root_two();
/// Return sqrt(3). /// Return sqrt(3).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_three(); GLM_FUNC_DECL genType root_three();
/// Return sqrt(5). /// Return sqrt(5).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType root_five(); GLM_FUNC_DECL genType root_five();
/// Return ln(2). /// Return ln(2).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType ln_two(); GLM_FUNC_DECL genType ln_two();
/// Return ln(10). /// Return ln(10).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType ln_ten(); GLM_FUNC_DECL genType ln_ten();
/// Return ln(ln(2)). /// Return ln(ln(2)).
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType ln_ln_two(); GLM_FUNC_DECL genType ln_ln_two();
/// Return 1 / 3. /// Return 1 / 3.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType third(); GLM_FUNC_DECL genType third();
/// Return 2 / 3. /// Return 2 / 3.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType two_thirds(); GLM_FUNC_DECL genType two_thirds();
/// Return the golden ratio constant. /// Return the golden ratio constant.
/// @see gtc_constants /// @see gtc_constants
template <typename genType> template <typename genType>
genType golden_ratio(); GLM_FUNC_DECL genType golden_ratio();
/// @} /// @}
} //namespace glm } //namespace glm

198
glm/gtc/half_float.hpp
View File

@ -68,77 +68,77 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Accesses // Accesses
half & operator[](size_type i); GLM_FUNC_DECL half & operator[](size_type i);
half const & operator[](size_type i) const; GLM_FUNC_DECL half const & operator[](size_type i) const;
////////////////////////////////////// //////////////////////////////////////
// Implicit basic constructors // Implicit basic constructors
tvec2(); GLM_FUNC_DECL tvec2();
tvec2(tvec2<half, P> const & v); GLM_FUNC_DECL tvec2(tvec2<half, P> const & v);
////////////////////////////////////// //////////////////////////////////////
// Explicit basic constructors // Explicit basic constructors
explicit tvec2(ctor){} GLM_FUNC_DECL explicit tvec2(ctor){}
explicit tvec2( GLM_FUNC_DECL explicit tvec2(
half const & s); half const & s);
explicit tvec2( GLM_FUNC_DECL explicit tvec2(
half const & s1, half const & s1,
half const & s2); half const & s2);
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors
tvec2(tref2<half, P> const & r); GLM_FUNC_DECL tvec2(tref2<half, P> const & r);
////////////////////////////////////// //////////////////////////////////////
// Convertion scalar constructors // Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U> template <typename U>
explicit tvec2(U const & x); GLM_FUNC_DECL explicit tvec2(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V> template <typename U, typename V>
explicit tvec2(U const & x, V const & y); GLM_FUNC_DECL explicit tvec2(U const & x, V const & y);
////////////////////////////////////// //////////////////////////////////////
// Convertion vector constructors // Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec2(tvec2<U, Q> const & v); GLM_FUNC_DECL explicit tvec2(tvec2<U, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec2(tvec3<U, Q> const & v); GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec2(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
////////////////////////////////////// //////////////////////////////////////
// Unary arithmetic operators // Unary arithmetic operators
tvec2<half, P>& operator= (tvec2<half, P> const & v); GLM_FUNC_DECL tvec2<half, P>& operator= (tvec2<half, P> const & v);
tvec2<half, P>& operator+=(half const & s); GLM_FUNC_DECL tvec2<half, P>& operator+=(half const & s);
tvec2<half, P>& operator+=(tvec2<half, P> const & v); GLM_FUNC_DECL tvec2<half, P>& operator+=(tvec2<half, P> const & v);
tvec2<half, P>& operator-=(half const & s); GLM_FUNC_DECL tvec2<half, P>& operator-=(half const & s);
tvec2<half, P>& operator-=(tvec2<half, P> const & v); GLM_FUNC_DECL tvec2<half, P>& operator-=(tvec2<half, P> const & v);
tvec2<half, P>& operator*=(half const & s); GLM_FUNC_DECL tvec2<half, P>& operator*=(half const & s);
tvec2<half, P>& operator*=(tvec2<half, P> const & v); GLM_FUNC_DECL tvec2<half, P>& operator*=(tvec2<half, P> const & v);
tvec2<half, P>& operator/=(half const & s); GLM_FUNC_DECL tvec2<half, P>& operator/=(half const & s);
tvec2<half, P>& operator/=(tvec2<half, P> const & v); GLM_FUNC_DECL tvec2<half, P>& operator/=(tvec2<half, P> const & v);
tvec2<half, P>& operator++(); GLM_FUNC_DECL tvec2<half, P>& operator++();
tvec2<half, P>& operator--(); GLM_FUNC_DECL tvec2<half, P>& operator--();
////////////////////////////////////// //////////////////////////////////////
// Swizzle operators // Swizzle operators
half swizzle(comp X) const; GLM_FUNC_DECL half swizzle(comp X) const;
tvec2<half, P> swizzle(comp X, comp Y) const; GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const; GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const; GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<half, P> swizzle(comp X, comp Y); GLM_FUNC_DECL tref2<half, P> swizzle(comp X, comp Y);
}; };
template <precision P> template <precision P>
@ -160,22 +160,22 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Accesses // Accesses
half & operator[](size_type i); GLM_FUNC_DECL half & operator[](size_type i);
half const & operator[](size_type i) const; GLM_FUNC_DECL half const & operator[](size_type i) const;
////////////////////////////////////// //////////////////////////////////////
// Implicit basic constructors // Implicit basic constructors
tvec3(); GLM_FUNC_DECL tvec3();
tvec3(tvec3<half, P> const & v); GLM_FUNC_DECL tvec3(tvec3<half, P> const & v);
////////////////////////////////////// //////////////////////////////////////
// Explicit basic constructors // Explicit basic constructors
explicit tvec3(ctor){} GLM_FUNC_DECL explicit tvec3(ctor){}
explicit tvec3( GLM_FUNC_DECL explicit tvec3(
half const & s); half const & s);
explicit tvec3( GLM_FUNC_DECL explicit tvec3(
half const & s1, half const & s1,
half const & s2, half const & s2,
half const & s3); half const & s3);
@ -183,58 +183,59 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors
tvec3(tref3<half, P> const & r); GLM_FUNC_DECL tvec3(tref3<half, P> const & r);
////////////////////////////////////// //////////////////////////////////////
// Convertion scalar constructors // Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U> template <typename U>
explicit tvec3(U const & x); GLM_FUNC_DECL explicit tvec3(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V, typename W> template <typename U, typename V, typename W>
explicit tvec3(U const & x, V const & y, W const & z); GLM_FUNC_DECL explicit tvec3(U const & x, V const & y, W const & z);
////////////////////////////////////// //////////////////////////////////////
// Convertion vector constructors // Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
explicit tvec3(tvec2<A, Q> const & v, B const & s); GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
explicit tvec3(A const & s, tvec2<B, Q> const & v); GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec3(tvec3<U, Q> const & v); GLM_FUNC_DECL explicit tvec3(tvec3<U, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec3(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
////////////////////////////////////// //////////////////////////////////////
// Unary arithmetic operators // Unary arithmetic operators
tvec3<half, P>& operator= (tvec3<half, P> const & v); GLM_FUNC_DECL tvec3<half, P>& operator= (tvec3<half, P> const & v);
tvec3<half, P>& operator+=(half const & s); GLM_FUNC_DECL tvec3<half, P>& operator+=(half const & s);
tvec3<half, P>& operator+=(tvec3<half, P> const & v); GLM_FUNC_DECL tvec3<half, P>& operator+=(tvec3<half, P> const & v);
tvec3<half, P>& operator-=(half const & s); GLM_FUNC_DECL tvec3<half, P>& operator-=(half const & s);
tvec3<half, P>& operator-=(tvec3<half, P> const & v); GLM_FUNC_DECL tvec3<half, P>& operator-=(tvec3<half, P> const & v);
tvec3<half, P>& operator*=(half const & s); GLM_FUNC_DECL tvec3<half, P>& operator*=(half const & s);
tvec3<half, P>& operator*=(tvec3<half, P> const & v); GLM_FUNC_DECL tvec3<half, P>& operator*=(tvec3<half, P> const & v);
tvec3<half, P>& operator/=(half const & s); GLM_FUNC_DECL tvec3<half, P>& operator/=(half const & s);
tvec3<half, P>& operator/=(tvec3<half, P> const & v); GLM_FUNC_DECL tvec3<half, P>& operator/=(tvec3<half, P> const & v);
tvec3<half, P>& operator++(); GLM_FUNC_DECL tvec3<half, P>& operator++();
tvec3<half, P>& operator--(); GLM_FUNC_DECL tvec3<half, P>& operator--();
////////////////////////////////////// //////////////////////////////////////
// Swizzle operators // Swizzle operators
half swizzle(comp X) const; GLM_FUNC_DECL half swizzle(comp X) const;
tvec2<half, P> swizzle(comp X, comp Y) const; GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const; GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const; GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<half, P> swizzle(comp X, comp Y, comp Z); GLM_FUNC_DECL tref3<half, P> swizzle(comp X, comp Y, comp Z);
}; };
template <precision P> template <precision P>
@ -256,22 +257,23 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Accesses // Accesses
half & operator[](size_type i); GLM_FUNC_DECL half & operator[](size_type i);
half const & operator[](size_type i) const; GLM_FUNC_DECL half const & operator[](size_type i) const;
////////////////////////////////////// //////////////////////////////////////
// Implicit basic constructors // Implicit basic constructors
tvec4(); GLM_FUNC_DECL tvec4();
tvec4(tvec4<half, P> const & v); GLM_FUNC_DECL tvec4(tvec4<half, P> const & v);
////////////////////////////////////// //////////////////////////////////////
// Explicit basic constructors // Explicit basic constructors
explicit tvec4(ctor){}
explicit tvec4( GLM_FUNC_DECL explicit tvec4(ctor){}
GLM_FUNC_DECL explicit tvec4(
half const & s); half const & s);
explicit tvec4( GLM_FUNC_DECL explicit tvec4(
half const & s0, half const & s0,
half const & s1, half const & s1,
half const & s2, half const & s2,
@ -280,67 +282,67 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors
tvec4(tref4<half, P> const & r); GLM_FUNC_DECL tvec4(tref4<half, P> const & r);
////////////////////////////////////// //////////////////////////////////////
// Convertion scalar constructors // Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U> template <typename U>
explicit tvec4(U const & x); GLM_FUNC_DECL explicit tvec4(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, typename D> template <typename A, typename B, typename C, typename D>
explicit tvec4(A const & x, B const & y, C const & z, D const & w); GLM_FUNC_DECL explicit tvec4(A const & x, B const & y, C const & z, D const & w);
////////////////////////////////////// //////////////////////////////////////
// Convertion vector constructors // Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
explicit tvec4(tvec2<A, Q> const & v, B const & s1, C const & s2); GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
explicit tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2); GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v); GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
explicit tvec4(tvec3<A, Q> const & v, B const & s); GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
explicit tvec4(A const & s, tvec3<B, Q> const & v); GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B, Q> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> const & v2); GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) //! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q> template <typename U, precision Q>
explicit tvec4(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
////////////////////////////////////// //////////////////////////////////////
// Unary arithmetic operators // Unary arithmetic operators
tvec4<half, P>& operator= (tvec4<half, P> const & v); GLM_FUNC_DECL tvec4<half, P>& operator= (tvec4<half, P> const & v);
tvec4<half, P>& operator+=(half const & s); GLM_FUNC_DECL tvec4<half, P>& operator+=(half const & s);
tvec4<half, P>& operator+=(tvec4<half, P> const & v); GLM_FUNC_DECL tvec4<half, P>& operator+=(tvec4<half, P> const & v);
tvec4<half, P>& operator-=(half const & s); GLM_FUNC_DECL tvec4<half, P>& operator-=(half const & s);
tvec4<half, P>& operator-=(tvec4<half, P> const & v); GLM_FUNC_DECL tvec4<half, P>& operator-=(tvec4<half, P> const & v);
tvec4<half, P>& operator*=(half const & s); GLM_FUNC_DECL tvec4<half, P>& operator*=(half const & s);
tvec4<half, P>& operator*=(tvec4<half, P> const & v); GLM_FUNC_DECL tvec4<half, P>& operator*=(tvec4<half, P> const & v);
tvec4<half, P>& operator/=(half const & s); GLM_FUNC_DECL tvec4<half, P>& operator/=(half const & s);
tvec4<half, P>& operator/=(tvec4<half, P> const & v); GLM_FUNC_DECL tvec4<half, P>& operator/=(tvec4<half, P> const & v);
tvec4<half, P>& operator++(); GLM_FUNC_DECL tvec4<half, P>& operator++();
tvec4<half, P>& operator--(); GLM_FUNC_DECL tvec4<half, P>& operator--();
////////////////////////////////////// //////////////////////////////////////
// Swizzle operators // Swizzle operators
half swizzle(comp X) const; GLM_FUNC_DECL half swizzle(comp X) const;
tvec2<half, P> swizzle(comp X, comp Y) const; GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const; GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const; GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<half, P> swizzle(comp X, comp Y, comp Z, comp W); GLM_FUNC_DECL tref4<half, P> swizzle(comp X, comp Y, comp Z, comp W);
}; };
#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98) #endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
} }
@ -647,19 +649,19 @@ namespace detail
/// Returns the absolute value of a half-precision floating-point value /// Returns the absolute value of a half-precision floating-point value
/// @see gtc_half_float /// @see gtc_half_float
half abs(half const & x); GLM_FUNC_DECL half abs(half const & x);
/// Returns the absolute value of a half-precision floating-point two dimensional vector /// Returns the absolute value of a half-precision floating-point two dimensional vector
/// @see gtc_half_float /// @see gtc_half_float
hvec2 abs(hvec2 const & x); GLM_FUNC_DECL hvec2 abs(hvec2 const & x);
/// Returns the absolute value of a half-precision floating-point three dimensional vector /// Returns the absolute value of a half-precision floating-point three dimensional vector
/// @see gtc_half_float /// @see gtc_half_float
hvec3 abs(hvec3 const & x); GLM_FUNC_DECL hvec3 abs(hvec3 const & x);
/// Returns the absolute value of a half-precision floating-point four dimensional vector /// Returns the absolute value of a half-precision floating-point four dimensional vector
/// @see gtc_half_float /// @see gtc_half_float
hvec4 abs(hvec4 const & x); GLM_FUNC_DECL hvec4 abs(hvec4 const & x);
/// Selects which vector each returned component comes /// Selects which vector each returned component comes
/// from. For a component of <a> that is false, the /// from. For a component of <a> that is false, the
@ -673,7 +675,7 @@ namespace detail
/// where a is a Boolean vector. /// where a is a Boolean vector.
/// ///
/// @see gtc_half_float /// @see gtc_half_float
half mix(half const & x, half const & y, bool const & a); GLM_FUNC_DECL half mix(half const & x, half const & y, bool const & a);
/// @} /// @}
}// namespace glm }// namespace glm