mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-22 08:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '0.9.5' into cxx11

Browse Source
This commit is contained in:
Christophe Riccio 2013-05-27 14:55:24 +00:00
commit d7fde821b1
27 changed files with 469 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
glm/core/_swizzle.hpp
View File

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

71
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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.
///
@ -60,7 +60,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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.
/// The fraction 0.5 will round in a direction chosen by the
@ -92,7 +92,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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.
/// A fractional part of 0.5 will round toward the nearest even
@ -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://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
template <typename genType>
genType roundEven(genType const & x);
GLM_FUNC_DECL genType roundEven(genType const & x);
/// Returns a value equal to the nearest integer
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType ceil(genType const & x);
GLM_FUNC_DECL genType ceil(genType const & 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType fract(genType const & x);
GLM_FUNC_DECL genType fract(genType const & x);
/// Modulus. Returns x - y * floor(x / 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType mod(
GLM_FUNC_DECL genType mod(
genType const & x,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType mod(
GLM_FUNC_DECL genType mod(
genType const & x,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType modf(
GLM_FUNC_DECL genType modf(
genType const & x,
genType & i);
@ -168,14 +168,14 @@ namespace glm
/// @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/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>
genType min(
GLM_FUNC_DECL genType min(
genType const & x,
genType const & y);
template <typename genType>
genType min(
GLM_FUNC_DECL genType min(
genType const & x,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType max(
GLM_FUNC_DECL genType max(
genType const & x,
genType const & y);
template <typename genType>
genType max(
GLM_FUNC_DECL genType max(
genType const & x,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType clamp(
GLM_FUNC_DECL genType clamp(
genType const & x,
genType const & minVal,
genType const & maxVal);
template <typename genType, precision P>
genType clamp(
GLM_FUNC_DECL genType clamp(
genType const & x,
typename genType::value_type const & minVal,
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.
/// @endcode
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType step(
GLM_FUNC_DECL genType step(
genType const & edge,
genType const & x);
template <typename genType>
genType step(
GLM_FUNC_DECL genType step(
typename genType::value_type const & edge,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
genType smoothstep(
GLM_FUNC_DECL genType smoothstep(
genType const & edge0,
genType const & edge1,
genType const & x);
template <typename genType>
genType smoothstep(
GLM_FUNC_DECL genType smoothstep(
typename genType::value_type const & edge0,
typename genType::value_type const & edge1,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
genIType floatBitsToInt(genType const & value);
GLM_FUNC_DECL genIType floatBitsToInt(genType const & value);
/// Returns a unsigned integer value representing
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// 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
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
/// 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
template <typename genType, typename genUType>
genType uintBitsToFloat(genUType const & value);
GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// [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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
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

4
glm/core/func_common.inl
View File

@ -36,7 +36,7 @@ namespace detail
template <typename genFIType>
struct Abs_<genFIType, true>
{
static genFIType get(genFIType const & x)
GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
{
GLM_STATIC_ASSERT(
detail::type<genFIType>::is_float ||
@ -49,7 +49,7 @@ namespace detail
template <typename genFIType>
struct Abs_<genFIType, false>
{
static genFIType get(genFIType const & x)
GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
{
GLM_STATIC_ASSERT(
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
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 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
genType log(genType const & x);
GLM_FUNC_DECL genType log(genType const & x);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
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,
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
genType log2(genType const & x);
GLM_FUNC_DECL genType log2(genType const & 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
genType inversesqrt(genType const & x);
GLM_FUNC_DECL genType inversesqrt(genType const & x);
/// @}
}//namespace glm

1
glm/core/func_exponential.inl
View File

@ -146,6 +146,7 @@ namespace _detail
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
assert(x > genType(0));
return genType(1) / ::std::sqrt(x);
}

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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
typename genType::value_type length(
GLM_FUNC_DECL typename genType::value_type length(
genType const & x);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
typename genType::value_type distance(
GLM_FUNC_DECL typename genType::value_type distance(
genType const & p0,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
typename genType::value_type dot(
GLM_FUNC_DECL typename genType::value_type dot(
genType const & x,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
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 & 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
genType normalize(
GLM_FUNC_DECL genType normalize(
genType const & x);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
genType faceforward(
GLM_FUNC_DECL genType faceforward(
genType const & N,
genType const & I,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
genType reflect(
GLM_FUNC_DECL genType reflect(
genType const & I,
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
genType refract(
GLM_FUNC_DECL genType refract(
genType const & I,
genType const & N,
typename genType::value_type const & eta);

20
glm/core/func_integer.hpp
View File

@ -52,7 +52,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
genUType uaddCarry(
GLM_FUNC_DECL genUType uaddCarry(
genUType const & x,
genUType const & y,
genUType & carry);
@ -66,7 +66,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
genUType usubBorrow(
GLM_FUNC_DECL genUType usubBorrow(
genUType const & x,
genUType const & y,
genUType & borrow);
@ -80,7 +80,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
void umulExtended(
GLM_FUNC_DECL void umulExtended(
genUType const & x,
genUType const & y,
genUType & msb,
@ -95,7 +95,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIType>
void imulExtended(
GLM_FUNC_DECL void imulExtended(
genIType const & x,
genIType const & y,
genIType & msb,
@ -117,7 +117,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType>
genIUType bitfieldExtract(
GLM_FUNC_DECL genIUType bitfieldExtract(
genIUType const & Value,
int const & Offset,
int const & Bits);
@ -137,7 +137,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType>
genIUType bitfieldInsert(
GLM_FUNC_DECL genIUType bitfieldInsert(
genIUType const & Base,
genIUType const & Insert,
int const & Offset,
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
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.
///
@ -163,7 +163,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that scalars are suported.
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
/// 1 in the binary representation of value.
@ -176,7 +176,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that scalars are suported.
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.
/// 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.
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

18
glm/core/func_matrix.hpp
View File

@ -53,7 +53,7 @@ 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType>
matType matrixCompMult(
GLM_FUNC_DECL matType matrixCompMult(
matType const & x,
matType const & y);
@ -68,7 +68,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
template <typename vecType, typename matType>
matType outerProduct(
GLM_FUNC_DECL matType outerProduct(
vecType const & c,
vecType const & r);
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType>
typename matType::transpose_type transpose(
GLM_FUNC_DECL typename matType::transpose_type transpose(
matType const & x);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
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);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
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);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
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);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P>
detail::tmat2x2<T, P> inverse(
GLM_FUNC_DECL detail::tmat2x2<T, P> inverse(
detail::tmat2x2<T, P> const & m);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P>
detail::tmat3x3<T, P> inverse(
GLM_FUNC_DECL detail::tmat3x3<T, P> inverse(
detail::tmat3x3<T, P> const & m);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename T, precision P>
detail::tmat4x4<T, P> inverse(
GLM_FUNC_DECL detail::tmat4x4<T, P> inverse(
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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
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.
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
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

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/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.
//! 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/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.
//! 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/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.
//! 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/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.
//! 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/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.
//! 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/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.
/// 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/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.
/// 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/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.
/// 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/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.
/// 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/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
/// 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/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,
/// 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/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

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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType radians(genType const & degrees);
GLM_FUNC_DECL genType radians(genType const & degrees);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType degrees(genType const & radians);
GLM_FUNC_DECL genType degrees(genType const & radians);
/// The standard trigonometric sine function.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType sin(genType const & angle);
GLM_FUNC_DECL genType sin(genType const & angle);
/// The standard trigonometric cosine function.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType cos(genType const & angle);
GLM_FUNC_DECL genType cos(genType const & angle);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
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)
///
@ -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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType tanh(genType const & angle);
GLM_FUNC_DECL genType tanh(genType const & angle);
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType asinh(genType const & x);
GLM_FUNC_DECL genType asinh(genType const & x);
/// Arc hyperbolic cosine; returns the non-negative inverse
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType acosh(genType const & x);
GLM_FUNC_DECL genType acosh(genType const & x);
/// Arc hyperbolic tangent; returns the inverse of tanh.
/// 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/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
genType atanh(genType const & x);
GLM_FUNC_DECL genType atanh(genType const & x);
/// @}
}//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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
///
@ -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/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>
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.
/// /!\ 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/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>
vecType<bool, P> not_(vecType<bool, P> const & v);
GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
/// @}
}//namespace glm

40
glm/core/type_mat2x2.hpp
View File

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

29
glm/core/type_mat2x4.hpp
View File

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

34
glm/core/type_mat3x2.hpp
View File

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

44
glm/core/type_mat3x3.hpp
View File

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

38
glm/core/type_mat3x4.hpp
View File

@ -79,12 +79,10 @@ namespace detail
GLM_FUNC_DECL explicit tmat3x4(
U const & x);
template
<
template<
typename X1, typename Y1, typename Z1, typename W1,
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(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
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);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x4<T, P> & operator= (tmat3x4<T, P> const & m);
@ -143,73 +141,73 @@ namespace detail
// Binary operators
template <typename T, precision P>
tmat3x4<T, P> operator+ (
GLM_FUNC_DECL tmat3x4<T, P> operator+ (
tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s);
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 & m2);
template <typename T, precision P>
tmat3x4<T, P> operator- (
GLM_FUNC_DECL tmat3x4<T, P> operator- (
tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s);
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 & m2);
template <typename T, precision P>
tmat3x4<T, P> operator* (
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P>
tmat3x4<T, P> operator* (
GLM_FUNC_DECL tmat3x4<T, P> operator* (
typename tmat3x4<T, P>::value_type const & s,
tmat3x4<T, P> const & m);
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,
typename tmat3x4<T, P>::row_type const & v);
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,
tmat3x4<T, P> const & m);
template <typename T, precision P>
tmat4x4<T, P> operator* (
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
tmat2x4<T, P> operator* (
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
tmat3x4<T, P> operator* (
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
tmat3x4<T, P> operator/ (
GLM_FUNC_DECL tmat3x4<T, P> operator/ (
tmat3x4<T, P> const & m,
typename tmat3x4<T, P>::value_type const & s);
template <typename T, precision P>
tmat3x4<T, P> operator/ (
GLM_FUNC_DECL tmat3x4<T, P> operator/ (
typename tmat3x4<T, P>::value_type const & s,
tmat3x4<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
tmat3x4<T, P> const operator-(
GLM_FUNC_DECL tmat3x4<T, P> const operator-(
tmat3x4<T, P> const & m);
}//namespace detail

34
glm/core/type_mat4x2.hpp
View File

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

32
glm/core/type_mat4x3.hpp
View File

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

38
glm/core/type_mat4x4.hpp
View File

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

2
glm/core/type_vec2.hpp
View File

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

50
glm/gtc/constants.hpp
View File

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

196
glm/gtc/half_float.hpp
View File

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

2
readme.txt
View File

@ -53,6 +53,8 @@ GLM 0.9.5.0: 2013-XX-XX
- Fixed perspective with zNear == 0 (#71)
- Fixed slerp when costheta is close to 1
- Fixed mat4x2 value_type constructor
- Fixed glm.natvis for Visual C++ 12 #82
- Added assert in inversesqrt to detect division by zero. #61
================================================================================
GLM 0.9.4.3: 2013-03-20

4
util/glm.natvis
View File

@ -1,6 +1,8 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- GLM visualizers for Visual Studio 2012 -->
<!-- Put them into My Documents/Visual Studio 2012/Visualizers/ -->
<?xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
<Type Name="glm::detail::tvec2&lt;*&gt;">
<DisplayString>({x}, {y})</DisplayString>