libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-11-24 08:30:16 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity

(GLM) Remove GLM_FUNC_DECL

Browse Source
This commit is contained in:
twinaphex 2016-11-01 07:40:33 +01:00
parent fd1b57fb1a
commit bc90cdef8b
83 changed files with 1336 additions and 1382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
deps/glm/detail/func_common.hpp vendored
View File

@ -53,7 +53,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>
GLM_FUNC_DECL genType abs(genType const & x);
genType abs(genType const & x);
/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
///
@ -62,7 +62,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>
GLM_FUNC_DECL genType sign(genType const & x);
genType sign(genType const & x);
/// Returns a value equal to the nearest integer that is less then or equal to x.
///
@ -71,7 +71,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>
GLM_FUNC_DECL genType floor(genType const & x);
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.
@ -81,7 +81,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>
GLM_FUNC_DECL genType trunc(genType const & x);
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
@ -94,7 +94,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>
GLM_FUNC_DECL genType round(genType const & x);
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
@ -106,7 +106,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>
GLM_FUNC_DECL genType roundEven(genType const & x);
genType roundEven(genType const & x);
/// Returns a value equal to the nearest integer
/// that is greater than or equal to x.
@ -116,7 +116,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>
GLM_FUNC_DECL genType ceil(genType const & x);
genType ceil(genType const & x);
/// Return x - floor(x).
///
@ -125,7 +125,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>
GLM_FUNC_DECL genType fract(genType const & x);
genType fract(genType const & x);
/// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y.
@ -135,7 +135,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>
GLM_FUNC_DECL genType mod(
genType mod(
genType const & x,
genType const & y);
@ -147,7 +147,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>
GLM_FUNC_DECL genType mod(
genType mod(
genType const & x,
typename genType::value_type const & y);
@ -161,7 +161,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>
GLM_FUNC_DECL genType modf(
genType modf(
genType const & x,
genType & i);
@ -172,12 +172,12 @@ namespace glm
/// @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><<<<<<< HEAD
template <typename genType>
GLM_FUNC_DECL genType min(
genType min(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType min(
genType min(
genType const & x,
typename genType::value_type const & y);
@ -188,12 +188,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>
GLM_FUNC_DECL genType max(
genType max(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType max(
genType max(
genType const & x,
typename genType::value_type const & y);
@ -205,13 +205,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>
GLM_FUNC_DECL genType clamp(
genType clamp(
genType const & x,
genType const & minVal,
genType const & maxVal);
template <typename genType, precision P>
GLM_FUNC_DECL genType clamp(
genType clamp(
genType const & x,
typename genType::value_type const & minVal,
typename genType::value_type const & maxVal);
@ -259,19 +259,19 @@ 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 T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mix(
vecType<T, P> mix(
vecType<T, P> const & x,
vecType<T, P> const & y,
vecType<U, P> const & a);
template <typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mix(
vecType<T, P> mix(
vecType<T, P> const & x,
vecType<T, P> const & y,
U const & a);
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT mix(
genTypeT mix(
genTypeT const & x,
genTypeT const & y,
genTypeU const & a);
@ -281,7 +281,7 @@ namespace glm
/// @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>
GLM_FUNC_DECL genType step(
genType step(
genType const & edge,
genType const & x);
@ -290,7 +290,7 @@ namespace glm
/// @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 <template <typename, precision> class vecType, typename T, precision P>
GLM_FUNC_DECL vecType<T, P> step(
vecType<T, P> step(
T const & edge,
vecType<T, P> const & x);
@ -309,13 +309,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>
GLM_FUNC_DECL genType smoothstep(
genType smoothstep(
genType const & edge0,
genType const & edge1,
genType const & x);
template <typename genType>
GLM_FUNC_DECL genType smoothstep(
genType smoothstep(
typename genType::value_type const & edge0,
typename genType::value_type const & edge1,
genType const & x);
@ -333,7 +333,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>
GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
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
@ -346,7 +346,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>
GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
typename genType::bool_type isinf(genType const & x);
/// Returns a signed integer value representing
/// the encoding of a floating-point value. The floating-point
@ -354,7 +354,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>
GLM_FUNC_DECL int floatBitsToInt(float const & v);
int floatBitsToInt(float const & v);
/// Returns a signed integer value representing
/// the encoding of a floating-point value. The floatingpoint
@ -363,7 +363,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 <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
/// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint
@ -371,7 +371,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>
GLM_FUNC_DECL uint floatBitsToUint(float const & v);
uint floatBitsToUint(float const & v);
/// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint
@ -380,7 +380,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 <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
/// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value.
@ -390,7 +390,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat 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>
GLM_FUNC_DECL float intBitsToFloat(int const & v);
float intBitsToFloat(int const & v);
/// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value.
@ -401,7 +401,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat 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 <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
/// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value.
@ -411,7 +411,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat 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>
GLM_FUNC_DECL float uintBitsToFloat(uint const & v);
float uintBitsToFloat(uint const & v);
/// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value.
@ -422,7 +422,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat 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 <template <typename, precision> class vecType, precision P>
GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
/// Computes and returns a * b + c.
///
@ -431,7 +431,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>
GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
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:
@ -448,7 +448,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>
GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
genType frexp(genType const & x, genIType & exp);
/// Builds a floating-point number from x and the
/// corresponding integral exponent of two in exp, returning:
@ -462,7 +462,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>
GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
genType ldexp(genType const & x, genIType const & exp);
/// @}
}//namespace glm

16
deps/glm/detail/func_exponential.hpp vendored
View File

@ -56,7 +56,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>
GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
genType pow(genType const & base, genType const & exponent);
/// Returns the natural exponentiation of x, i.e., e^x.
///
@ -66,7 +66,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>
GLM_FUNC_DECL genType exp(genType const & x);
genType exp(genType const & x);
/// Returns the natural logarithm of x, i.e.,
/// returns the value y which satisfies the equation x = e^y.
@ -78,7 +78,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>
GLM_FUNC_DECL genType log(genType const & x);
genType log(genType const & x);
/// Returns 2 raised to the x power.
///
@ -88,7 +88,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>
GLM_FUNC_DECL genType exp2(genType const & x);
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.
@ -99,7 +99,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>
GLM_FUNC_DECL genType log2(genType x);
genType log2(genType x);
/// Returns the positive square root of x.
///
@ -109,10 +109,10 @@ 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>
//GLM_FUNC_DECL genType sqrt(genType const & x);
// genType sqrt(genType const & x);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & x);
vecType<T, P> sqrt(vecType<T, P> const & x);
/// Returns the reciprocal of the positive square root of x.
///
@ -122,7 +122,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>
GLM_FUNC_DECL genType inversesqrt(genType const & x);
genType inversesqrt(genType const & x);
/// @}
}//namespace glm

18
deps/glm/detail/func_geometric.hpp vendored
View File

@ -50,7 +50,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>
GLM_FUNC_DECL typename genType::value_type length(
typename genType::value_type length(
genType const & x);
/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
@ -60,7 +60,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>
GLM_FUNC_DECL typename genType::value_type distance(
typename genType::value_type distance(
genType const & p0,
genType const & p1);
@ -71,7 +71,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 T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL T dot(
T dot(
vecType<T, P> const & x,
vecType<T, P> const & y);
@ -82,7 +82,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>
GLM_FUNC_DECL genType dot(
genType dot(
genType const & x,
genType const & y);
@ -93,7 +93,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>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> cross(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
@ -102,7 +102,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>
GLM_FUNC_DECL genType normalize(
genType normalize(
genType const & x);
/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
@ -112,7 +112,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>
GLM_FUNC_DECL genType faceforward(
genType faceforward(
genType const & N,
genType const & I,
genType const & Nref);
@ -125,7 +125,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>
GLM_FUNC_DECL genType reflect(
genType reflect(
genType const & I,
genType const & N);
@ -138,7 +138,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 T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> refract(
vecType<T, P> refract(
vecType<T, P> const & I,
vecType<T, P> const & N,
T const & eta);

20
deps/glm/detail/func_integer.hpp vendored
View File

@ -54,7 +54,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>
GLM_FUNC_DECL genUType uaddCarry(
genUType uaddCarry(
genUType const & x,
genUType const & y,
genUType & carry);
@ -68,7 +68,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>
GLM_FUNC_DECL genUType usubBorrow(
genUType usubBorrow(
genUType const & x,
genUType const & y,
genUType & borrow);
@ -82,7 +82,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>
GLM_FUNC_DECL void umulExtended(
void umulExtended(
genUType const & x,
genUType const & y,
genUType & msb,
@ -97,7 +97,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>
GLM_FUNC_DECL void imulExtended(
void imulExtended(
genIType const & x,
genIType const & y,
genIType & msb,
@ -119,7 +119,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>
GLM_FUNC_DECL genIUType bitfieldExtract(
genIUType bitfieldExtract(
genIUType const & Value,
int const & Offset,
int const & Bits);
@ -139,7 +139,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>
GLM_FUNC_DECL genIUType bitfieldInsert(
genIUType bitfieldInsert(
genIUType const & Base,
genIUType const & Insert,
int const & Offset,
@ -154,7 +154,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>
GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
genIUType bitfieldReverse(genIUType const & Value);
/// Returns the number of bits set to 1 in the binary representation of value.
///
@ -165,7 +165,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
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.
@ -178,7 +178,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
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.
@ -192,7 +192,7 @@ namespace glm
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
/// @}
}//namespace glm

10
deps/glm/detail/func_matrix.hpp vendored
View File

@ -127,7 +127,7 @@ namespace detail
/// @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 T, precision P, template <typename, precision> class matType>
GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
/// Treats the first parameter c as a column vector
/// and the second parameter r as a row vector
@ -140,7 +140,7 @@ namespace detail
///
/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
/// Returns the transposed matrix of x
///
@ -150,7 +150,7 @@ namespace detail
/// @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>
# if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))
template <typename T, precision P, template <typename, precision> class matType>
GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
# endif
/// Return the determinant of a squared matrix.
@ -160,7 +160,7 @@ namespace detail
/// @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, template <typename, precision> class matType>
GLM_FUNC_DECL T determinant(matType<T, P> const & m);
T determinant(matType<T, P> const & m);
/// Return the inverse of a squared matrix.
///
@ -169,7 +169,7 @@ namespace detail
/// @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, template <typename, precision> class matType>
GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
matType<T, P> inverse(matType<T, P> const & m);
/// @}
}//namespace glm

8
deps/glm/detail/func_noise.hpp vendored
View File

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

24
deps/glm/detail/func_packing.hpp vendored
View File

@ -55,7 +55,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>
GLM_FUNC_DECL uint packUnorm2x16(vec2 const & v);
uint 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.
@ -68,7 +68,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>
GLM_FUNC_DECL uint packSnorm2x16(vec2 const & v);
uint 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.
@ -81,7 +81,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>
GLM_FUNC_DECL uint packUnorm4x8(vec4 const & v);
uint 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.
@ -94,7 +94,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>
GLM_FUNC_DECL uint packSnorm4x8(vec4 const & v);
uint 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.
@ -107,7 +107,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>
GLM_FUNC_DECL vec2 unpackUnorm2x16(uint const & p);
vec2 unpackUnorm2x16(uint 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.
@ -120,7 +120,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>
GLM_FUNC_DECL vec2 unpackSnorm2x16(uint const & p);
vec2 unpackSnorm2x16(uint 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.
@ -133,7 +133,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>
GLM_FUNC_DECL vec4 unpackUnorm4x8(uint const & p);
vec4 unpackUnorm4x8(uint 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.
@ -146,7 +146,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>
GLM_FUNC_DECL vec4 unpackSnorm4x8(uint const & p);
vec4 unpackSnorm4x8(uint 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.
@ -156,7 +156,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>
GLM_FUNC_DECL double packDouble2x32(uvec2 const & v);
double packDouble2x32(uvec2 const & v);
/// Returns a two-component unsigned integer vector representation of v.
/// The bit-level representation of v is preserved.
@ -165,7 +165,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>
GLM_FUNC_DECL uvec2 unpackDouble2x32(double const & v);
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,
@ -175,7 +175,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>
GLM_FUNC_DECL uint packHalf2x16(vec2 const & v);
uint 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,
@ -185,7 +185,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>
GLM_FUNC_DECL vec2 unpackHalf2x16(uint const & v);
vec2 unpackHalf2x16(uint const & v);
/// @}
}//namespace glm

30
deps/glm/detail/func_trigonometric.hpp vendored
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>
GLM_FUNC_DECL genType radians(genType const & degrees);
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>
GLM_FUNC_DECL genType degrees(genType const & radians);
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>
GLM_FUNC_DECL genType sin(genType const & angle);
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>
GLM_FUNC_DECL genType cos(genType const & angle);
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>
GLM_FUNC_DECL genType tan(genType const & angle);
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>
GLM_FUNC_DECL genType asin(genType const & x);
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>
GLM_FUNC_DECL genType acos(genType const & x);
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>
GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
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>
GLM_FUNC_DECL genType atan(genType const & y_over_x);
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>
GLM_FUNC_DECL genType sinh(genType const & angle);
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>
GLM_FUNC_DECL genType cosh(genType const & angle);
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>
GLM_FUNC_DECL genType tanh(genType const & angle);
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>
GLM_FUNC_DECL genType asinh(genType const & x);
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>
GLM_FUNC_DECL genType acosh(genType const & x);
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>
GLM_FUNC_DECL genType atanh(genType const & x);
genType atanh(genType const & x);
/// @}
}//namespace glm

18
deps/glm/detail/func_vector_relational.hpp vendored
View File

@ -59,7 +59,7 @@ namespace glm
/// @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>
// TODO: Mismatched
//template <typename T, precision P, template <typename, precision> class vecType>
//GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
//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.
///
@ -68,7 +68,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>
GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
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.
///
@ -77,7 +77,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>
GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
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.
///
@ -86,7 +86,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>
GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
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.
///
@ -96,7 +96,7 @@ namespace glm
/// @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>
//TODO: conflicts with definision
//template <typename T, precision P, template <typename, precision> class vecType>
//GLM_FUNC_DECL typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y);
//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.
///
@ -105,7 +105,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>
GLM_FUNC_DECL typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
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.
///
@ -114,7 +114,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>
GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
bool any(vecType<bool, P> const & v);
/// Returns true if all components of x are true.
///
@ -123,7 +123,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>
GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
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.
@ -133,7 +133,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>
GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
vecType<bool, P> not_(vecType<bool, P> const & v);
/// @}
}//namespace glm

3
deps/glm/detail/setup.hpp vendored
View File

@ -665,8 +665,7 @@
# define GLM_INLINE inline
#endif//defined(GLM_FORCE_INLINE)
#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
#define GLM_FUNC_QUALIFIER GLM_INLINE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Swizzle operators

4
deps/glm/detail/type_half.hpp vendored
View File

@ -34,8 +34,8 @@
namespace glm{
namespace detail
{
GLM_FUNC_DECL float toFloat32(int16_t value);
GLM_FUNC_DECL int16_t toFloat16(float const & value);
float toFloat32(int16_t value);
int16_t toFloat16(float const & value);
}//namespace detail
}//namespace glm

110
deps/glm/detail/type_mat2x2.hpp vendored
View File

@ -48,7 +48,7 @@ namespace detail
typedef tmat2x2<T, P> type;
typedef tmat2x2<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
template <typename U, precision Q>
friend tvec2<U, Q> operator/(tmat2x2<U, Q> const & m, tvec2<U, Q> const & v);
@ -63,181 +63,181 @@ namespace detail
public:
//////////////////////////////////////
// Constructors
GLM_FUNC_DECL tmat2x2();
GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m);
tmat2x2();
tmat2x2(tmat2x2<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
tmat2x2(tmat2x2<T, Q> const & m);
GLM_FUNC_DECL explicit tmat2x2(
explicit tmat2x2(
ctor Null);
GLM_FUNC_DECL explicit tmat2x2(
explicit tmat2x2(
T const & x);
GLM_FUNC_DECL tmat2x2(
tmat2x2(
T const & x1, T const & y1,
T const & x2, T const & y2);
GLM_FUNC_DECL tmat2x2(
tmat2x2(
col_type const & v1,
col_type const & v2);
//////////////////////////////////////
// Conversions
template <typename U, typename V, typename M, typename N>
GLM_FUNC_DECL tmat2x2(
tmat2x2(
U const & x1, V const & y1,
M const & x2, N const & y2);
template <typename U, typename V>
GLM_FUNC_DECL tmat2x2(
tmat2x2(
tvec2<U, P> const & v1,
tvec2<V, P> const & v2);
//////////////////////////////////////
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
explicit tmat2x2(tmat2x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T, P> const & x);
explicit tmat2x2(tmat3x3<T, P> const & x);
explicit tmat2x2(tmat4x4<T, P> const & x);
explicit tmat2x2(tmat2x3<T, P> const & x);
explicit tmat2x2(tmat3x2<T, P> const & x);
explicit tmat2x2(tmat2x4<T, P> const & x);
explicit tmat2x2(tmat4x2<T, P> const & x);
explicit tmat2x2(tmat3x4<T, P> const & x);
explicit tmat2x2(tmat4x3<T, P> const & x);
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & m);
tmat2x2<T, P> & operator=(tmat2x2<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
tmat2x2<T, P> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
tmat2x2<T, P> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
tmat2x2<T, P> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
tmat2x2<T, P> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
GLM_FUNC_DECL tmat2x2<T, P> operator++(int);
GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
tmat2x2<T, P> & operator++ ();
tmat2x2<T, P> & operator-- ();
tmat2x2<T, P> operator++(int);
tmat2x2<T, P> operator--(int);
};
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> compute_inverse_mat2(tmat2x2<T, P> const & m);
tmat2x2<T, P> compute_inverse_mat2(tmat2x2<T, P> const & m);
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator+ (
tmat2x2<T, P> operator+ (
tmat2x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator+ (
tmat2x2<T, P> operator+ (
T const & s,
tmat2x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator+ (
tmat2x2<T, P> operator+ (
tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator- (
tmat2x2<T, P> operator- (
tmat2x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator- (
tmat2x2<T, P> operator- (
T const & s,
tmat2x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator- (
tmat2x2<T, P> operator- (
tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> operator* (
tmat2x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> operator* (
T const & s,
tmat2x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> operator* (
tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> operator* (
tmat2x2<T, P> const & m1,
tmat3x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> operator* (
tmat2x2<T, P> const & m1,
tmat4x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator/ (
tmat2x2<T, P> operator/ (
tmat2x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> operator/ (
tmat2x2<T, P> operator/ (
T const & s,
tmat2x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/ (
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>
GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/ (
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>
GLM_FUNC_DECL tmat2x2<T, P> operator/ (
tmat2x2<T, P> operator/ (
tmat2x2<T, P> const & m1,
tmat2x2<T, P> const & m2);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x2<T, P> const operator-(
tmat2x2<T, P> const operator-(
tmat2x2<T, P> const & m);
} //namespace detail
} //namespace glm

94
deps/glm/detail/type_mat2x3.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat2x3<T, P> type;
typedef tmat3x2<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,148 +57,148 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat2x3();
GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m);
tmat2x3();
tmat2x3(tmat2x3<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
tmat2x3(tmat2x3<T, Q> const & m);
GLM_FUNC_DECL explicit tmat2x3(
explicit tmat2x3(
ctor);
GLM_FUNC_DECL explicit tmat2x3(
explicit tmat2x3(
T const & s);
GLM_FUNC_DECL tmat2x3(
tmat2x3(
T const & x0, T const & y0, T const & z0,
T const & x1, T const & y1, T const & z1);
GLM_FUNC_DECL tmat2x3(
tmat2x3(
col_type const & v0,
col_type const & v1);
//////////////////////////////////////
// Conversions
template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
GLM_FUNC_DECL tmat2x3(
tmat2x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2);
template <typename U, typename V>
GLM_FUNC_DECL tmat2x3(
tmat2x3(
tvec3<U, P> const & v1,
tvec3<V, P> const & v2);
//////////////////////////////////////
// Matrix conversion
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
explicit tmat2x3(tmat2x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);
explicit tmat2x3(tmat2x2<T, P> const & x);
explicit tmat2x3(tmat3x3<T, P> const & x);
explicit tmat2x3(tmat4x4<T, P> const & x);
explicit tmat2x3(tmat2x4<T, P> const & x);
explicit tmat2x3(tmat3x2<T, P> const & x);
explicit tmat2x3(tmat3x4<T, P> const & x);
explicit tmat2x3(tmat4x2<T, P> const & x);
explicit tmat2x3(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x3<T, P> & operator= (tmat2x3<T, P> const & m);
tmat2x3<T, P> & operator= (tmat2x3<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator= (tmat2x3<U, P> const & m);
tmat2x3<T, P> & operator= (tmat2x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator+= (U s);
tmat2x3<T, P> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator+= (tmat2x3<U, P> const & m);
tmat2x3<T, P> & operator+= (tmat2x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator-= (U s);
tmat2x3<T, P> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator-= (tmat2x3<U, P> const & m);
tmat2x3<T, P> & operator-= (tmat2x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator*= (U s);
tmat2x3<T, P> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T, P> & operator/= (U s);
tmat2x3<T, P> & operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
GLM_FUNC_DECL tmat2x3<T, P> operator++(int);
GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
tmat2x3<T, P> & operator++ ();
tmat2x3<T, P> & operator-- ();
tmat2x3<T, P> operator++(int);
tmat2x3<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator+ (
tmat2x3<T, P> operator+ (
tmat2x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator+ (
tmat2x3<T, P> operator+ (
tmat2x3<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator- (
tmat2x3<T, P> operator- (
tmat2x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator- (
tmat2x3<T, P> operator- (
tmat2x3<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
tmat2x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
T const & s,
tmat2x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
tmat2x3<T, P> const & m1,
tmat2x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> operator* (
tmat2x3<T, P> const & m1,
tmat3x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> operator* (
tmat2x3<T, P> const & m1,
tmat4x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator/ (
tmat2x3<T, P> operator/ (
tmat2x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator/ (
tmat2x3<T, P> operator/ (
T const & s,
tmat2x3<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> const operator- (
tmat2x3<T, P> const operator- (
tmat2x3<T, P> const & m);
}//namespace detail

94
deps/glm/detail/type_mat2x4.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat2x4<T, P> type;
typedef tmat4x2<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,19 +57,19 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat2x4();
GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m);
tmat2x4();
tmat2x4(tmat2x4<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
tmat2x4(tmat2x4<T, Q> const & m);
GLM_FUNC_DECL explicit tmat2x4(
explicit tmat2x4(
ctor);
GLM_FUNC_DECL explicit tmat2x4(
explicit tmat2x4(
T const & s);
GLM_FUNC_DECL tmat2x4(
tmat2x4(
T const & x0, T const & y0, T const & z0, T const & w0,
T const & x1, T const & y1, T const & z1, T const & w1);
GLM_FUNC_DECL tmat2x4(
tmat2x4(
col_type const & v0,
col_type const & v1);
@ -78,129 +78,129 @@ namespace detail
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2>
GLM_FUNC_DECL tmat2x4(
tmat2x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
template <typename U, typename V>
GLM_FUNC_DECL tmat2x4(
tmat2x4(
tvec4<U, P> const & v1,
tvec4<V, P> const & v2);
//////////////////////////////////////
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m);
explicit tmat2x4(tmat2x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T, P> const & x);
explicit tmat2x4(tmat2x2<T, P> const & x);
explicit tmat2x4(tmat3x3<T, P> const & x);
explicit tmat2x4(tmat4x4<T, P> const & x);
explicit tmat2x4(tmat2x3<T, P> const & x);
explicit tmat2x4(tmat3x2<T, P> const & x);
explicit tmat2x4(tmat3x4<T, P> const & x);
explicit tmat2x4(tmat4x2<T, P> const & x);
explicit tmat2x4(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x4<T, P>& operator= (tmat2x4<T, P> const & m);
tmat2x4<T, P>& operator= (tmat2x4<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator= (tmat2x4<U, P> const & m);
tmat2x4<T, P>& operator= (tmat2x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator+= (U s);
tmat2x4<T, P>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator+= (tmat2x4<U, P> const & m);
tmat2x4<T, P>& operator+= (tmat2x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator-= (U s);
tmat2x4<T, P>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator-= (tmat2x4<U, P> const & m);
tmat2x4<T, P>& operator-= (tmat2x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator*= (U s);
tmat2x4<T, P>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T, P>& operator/= (U s);
tmat2x4<T, P>& operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat2x4<T, P> & operator++ ();
GLM_FUNC_DECL tmat2x4<T, P> & operator-- ();
GLM_FUNC_DECL tmat2x4<T, P> operator++(int);
GLM_FUNC_DECL tmat2x4<T, P> operator--(int);
tmat2x4<T, P> & operator++ ();
tmat2x4<T, P> & operator-- ();
tmat2x4<T, P> operator++(int);
tmat2x4<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator+ (
tmat2x4<T, P> operator+ (
tmat2x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator+ (
tmat2x4<T, P> operator+ (
tmat2x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator- (
tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator- (
tmat2x4<T, P> operator- (
tmat2x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> operator* (
tmat2x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> operator* (
T const & s,
tmat2x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> operator* (
tmat2x4<T, P> const & m1,
tmat4x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> operator* (
tmat2x4<T, P> const & m1,
tmat2x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> operator* (
tmat2x4<T, P> const & m1,
tmat3x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator/ (
tmat2x4<T, P> operator/ (
tmat2x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator/ (
tmat2x4<T, P> operator/ (
T const & s,
tmat2x4<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> const operator- (
tmat2x4<T, P> const operator- (
tmat2x4<T, P> const & m);
}//namespace detail

94
deps/glm/detail/type_mat3x2.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat3x2<T, P> type;
typedef tmat2x3<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,20 +57,20 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat3x2();
GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m);
tmat3x2();
tmat3x2(tmat3x2<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat3x2(tmat3x2<T, Q> const & m);
tmat3x2(tmat3x2<T, Q> const & m);
GLM_FUNC_DECL explicit tmat3x2(
explicit tmat3x2(
ctor);
GLM_FUNC_DECL explicit tmat3x2(
explicit tmat3x2(
T const & s);
GLM_FUNC_DECL tmat3x2(
tmat3x2(
T const & x0, T const & y0,
T const & x1, T const & y1,
T const & x2, T const & y2);
GLM_FUNC_DECL tmat3x2(
tmat3x2(
col_type const & v0,
col_type const & v1,
col_type const & v2);
@ -81,129 +81,129 @@ namespace detail
typename X1, typename Y1,
typename X2, typename Y2,
typename X3, typename Y3>
GLM_FUNC_DECL tmat3x2(
tmat3x2(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x2(
tmat3x2(
tvec2<V1, P> const & v1,
tvec2<V2, P> const & v2,
tvec2<V3, P> const & v3);
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m);
explicit tmat3x2(tmat3x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T, P> const & x);
explicit tmat3x2(tmat2x2<T, P> const & x);
explicit tmat3x2(tmat3x3<T, P> const & x);
explicit tmat3x2(tmat4x4<T, P> const & x);
explicit tmat3x2(tmat2x3<T, P> const & x);
explicit tmat3x2(tmat2x4<T, P> const & x);
explicit tmat3x2(tmat3x4<T, P> const & x);
explicit tmat3x2(tmat4x2<T, P> const & x);
explicit tmat3x2(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x2<T, P> & operator= (tmat3x2<T, P> const & m);
tmat3x2<T, P> & operator= (tmat3x2<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator= (tmat3x2<U, P> const & m);
tmat3x2<T, P> & operator= (tmat3x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator+= (U s);
tmat3x2<T, P> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator+= (tmat3x2<U, P> const & m);
tmat3x2<T, P> & operator+= (tmat3x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator-= (U s);
tmat3x2<T, P> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator-= (tmat3x2<U, P> const & m);
tmat3x2<T, P> & operator-= (tmat3x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator*= (U s);
tmat3x2<T, P> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T, P> & operator/= (U s);
tmat3x2<T, P> & operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat3x2<T, P> & operator++ ();
GLM_FUNC_DECL tmat3x2<T, P> & operator-- ();
GLM_FUNC_DECL tmat3x2<T, P> operator++(int);
GLM_FUNC_DECL tmat3x2<T, P> operator--(int);
tmat3x2<T, P> & operator++ ();
tmat3x2<T, P> & operator-- ();
tmat3x2<T, P> operator++(int);
tmat3x2<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator+ (
tmat3x2<T, P> operator+ (
tmat3x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator+ (
tmat3x2<T, P> operator+ (
tmat3x2<T, P> const & m1,
tmat3x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator- (
tmat3x2<T, P> operator- (
tmat3x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator- (
tmat3x2<T, P> operator- (
tmat3x2<T, P> const & m1,
tmat3x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> operator* (
tmat3x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> operator* (
T const & s,
tmat3x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat3x2<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat3x2<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat2x2<T, P> operator* (
tmat2x2<T, P> operator* (
tmat3x2<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> operator* (
tmat3x2<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> operator* (
tmat3x2<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator/ (
tmat3x2<T, P> operator/ (
tmat3x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> operator/ (
tmat3x2<T, P> operator/ (
T const & s,
tmat3x2<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x2<T, P> const operator-(
tmat3x2<T, P> const operator-(
tmat3x2<T, P> const & m);
}//namespace detail

110
deps/glm/detail/type_mat3x3.hpp vendored
View File

@ -48,7 +48,7 @@ namespace detail
typedef tmat3x3<T, P> type;
typedef tmat3x3<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
template <typename U, precision Q>
friend tvec3<U, Q> operator/(tmat3x3<U, Q> const & m, tvec3<U, Q> const & v);
@ -62,20 +62,20 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat3x3();
GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m);
tmat3x3();
tmat3x3(tmat3x3<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat3x3(tmat3x3<T, Q> const & m);
tmat3x3(tmat3x3<T, Q> const & m);
GLM_FUNC_DECL explicit tmat3x3(
explicit tmat3x3(
ctor Null);
GLM_FUNC_DECL explicit tmat3x3(
explicit tmat3x3(
T const & s);
GLM_FUNC_DECL tmat3x3(
tmat3x3(
T const & x0, T const & y0, T const & z0,
T const & x1, T const & y1, T const & z1,
T const & x2, T const & y2, T const & z2);
GLM_FUNC_DECL tmat3x3(
tmat3x3(
col_type const & v0,
col_type const & v1,
col_type const & v2);
@ -86,161 +86,161 @@ namespace detail
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3>
GLM_FUNC_DECL tmat3x3(
tmat3x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x3(
tmat3x3(
tvec3<V1, P> const & v1,
tvec3<V2, P> const & v2,
tvec3<V3, P> const & v3);
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m);
explicit tmat3x3(tmat3x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T, P> const & x);
explicit tmat3x3(tmat2x2<T, P> const & x);
explicit tmat3x3(tmat4x4<T, P> const & x);
explicit tmat3x3(tmat2x3<T, P> const & x);
explicit tmat3x3(tmat3x2<T, P> const & x);
explicit tmat3x3(tmat2x4<T, P> const & x);
explicit tmat3x3(tmat4x2<T, P> const & x);
explicit tmat3x3(tmat3x4<T, P> const & x);
explicit tmat3x3(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x3<T, P>& operator= (tmat3x3<T, P> const & m);
tmat3x3<T, P>& operator= (tmat3x3<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator= (tmat3x3<U, P> const & m);
tmat3x3<T, P>& operator= (tmat3x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator+= (U s);
tmat3x3<T, P>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator+= (tmat3x3<U, P> const & m);
tmat3x3<T, P>& operator+= (tmat3x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator-= (U s);
tmat3x3<T, P>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator-= (tmat3x3<U, P> const & m);
tmat3x3<T, P>& operator-= (tmat3x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator*= (U s);
tmat3x3<T, P>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator*= (tmat3x3<U, P> const & m);
tmat3x3<T, P>& operator*= (tmat3x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator/= (U s);
tmat3x3<T, P>& operator/= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T, P>& operator/= (tmat3x3<U, P> const & m);
tmat3x3<T, P>& operator/= (tmat3x3<U, P> const & m);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat3x3<T, P> & operator++ ();
GLM_FUNC_DECL tmat3x3<T, P> & operator-- ();
GLM_FUNC_DECL tmat3x3<T, P> operator++(int);
GLM_FUNC_DECL tmat3x3<T, P> operator--(int);
tmat3x3<T, P> & operator++ ();
tmat3x3<T, P> & operator-- ();
tmat3x3<T, P> operator++(int);
tmat3x3<T, P> operator--(int);
};
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> compute_inverse_mat3(tmat3x3<T, P> const & m);
tmat3x3<T, P> compute_inverse_mat3(tmat3x3<T, P> const & m);
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator+ (
tmat3x3<T, P> operator+ (
tmat3x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator+ (
tmat3x3<T, P> operator+ (
T const & s,
tmat3x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator+ (
tmat3x3<T, P> operator+ (
tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator- (
tmat3x3<T, P> operator- (
tmat3x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator- (
tmat3x3<T, P> operator- (
T const & s,
tmat3x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator- (
tmat3x3<T, P> operator- (
tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> operator* (
tmat3x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> operator* (
T const & s,
tmat3x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> operator* (
tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
tmat3x3<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> operator* (
tmat3x3<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator/ (
tmat3x3<T, P> operator/ (
tmat3x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator/ (
tmat3x3<T, P> operator/ (
T const & s,
tmat3x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator/ (
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>
GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator/ (
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>
GLM_FUNC_DECL tmat3x3<T, P> operator/ (
tmat3x3<T, P> operator/ (
tmat3x3<T, P> const & m1,
tmat3x3<T, P> const & m2);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> const operator-(
tmat3x3<T, P> const operator-(
tmat3x3<T, P> const & m);
}//namespace detail

94
deps/glm/detail/type_mat3x4.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat3x4<T, P> type;
typedef tmat4x3<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,20 +57,20 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat3x4();
GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m);
tmat3x4();
tmat3x4(tmat3x4<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat3x4(tmat3x4<T, Q> const & m);
tmat3x4(tmat3x4<T, Q> const & m);
GLM_FUNC_DECL explicit tmat3x4(
explicit tmat3x4(
ctor Null);
GLM_FUNC_DECL explicit tmat3x4(
explicit tmat3x4(
T const & s);
GLM_FUNC_DECL tmat3x4(
tmat3x4(
T const & x0, T const & y0, T const & z0, T const & w0,
T const & x1, T const & y1, T const & z1, T const & w1,
T const & x2, T const & y2, T const & z2, T const & w2);
GLM_FUNC_DECL tmat3x4(
tmat3x4(
col_type const & v0,
col_type const & v1,
col_type const & v2);
@ -81,129 +81,129 @@ namespace detail
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,
typename X3, typename Y3, typename Z3, typename W3>
GLM_FUNC_DECL tmat3x4(
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,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x4(
tmat3x4(
tvec4<V1, P> const & v1,
tvec4<V2, P> const & v2,
tvec4<V3, P> const & v3);
// Matrix conversion
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m);
explicit tmat3x4(tmat3x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x);
explicit tmat3x4(tmat2x2<T, P> const & x);
explicit tmat3x4(tmat3x3<T, P> const & x);
explicit tmat3x4(tmat4x4<T, P> const & x);
explicit tmat3x4(tmat2x3<T, P> const & x);
explicit tmat3x4(tmat3x2<T, P> const & x);
explicit tmat3x4(tmat2x4<T, P> const & x);
explicit tmat3x4(tmat4x2<T, P> const & x);
explicit tmat3x4(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x4<T, P> & operator= (tmat3x4<T, P> const & m);
tmat3x4<T, P> & operator= (tmat3x4<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator= (tmat3x4<U, P> const & m);
tmat3x4<T, P> & operator= (tmat3x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator+= (U s);
tmat3x4<T, P> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator+= (tmat3x4<U, P> const & m);
tmat3x4<T, P> & operator+= (tmat3x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator-= (U s);
tmat3x4<T, P> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator-= (tmat3x4<U, P> const & m);
tmat3x4<T, P> & operator-= (tmat3x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator*= (U s);
tmat3x4<T, P> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T, P> & operator/= (U s);
tmat3x4<T, P> & operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat3x4<T, P> & operator++ ();
GLM_FUNC_DECL tmat3x4<T, P> & operator-- ();
GLM_FUNC_DECL tmat3x4<T, P> operator++(int);
GLM_FUNC_DECL tmat3x4<T, P> operator--(int);
tmat3x4<T, P> & operator++ ();
tmat3x4<T, P> & operator-- ();
tmat3x4<T, P> operator++(int);
tmat3x4<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator+ (
tmat3x4<T, P> operator+ (
tmat3x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator+ (
tmat3x4<T, P> operator+ (
tmat3x4<T, P> const & m1,
tmat3x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator- (
tmat3x4<T, P> operator- (
tmat3x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator- (
tmat3x4<T, P> operator- (
tmat3x4<T, P> const & m1,
tmat3x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> operator* (
T const & s,
tmat3x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat3x4<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat3x4<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat2x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> operator* (
tmat3x4<T, P> const & m1,
tmat3x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator/ (
tmat3x4<T, P> operator/ (
tmat3x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator/ (
tmat3x4<T, P> operator/ (
T const & s,
tmat3x4<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> const operator-(
tmat3x4<T, P> const operator-(
tmat3x4<T, P> const & m);
}//namespace detail

94
deps/glm/detail/type_mat4x2.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat4x2<T, P> type;
typedef tmat2x4<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,21 +57,21 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat4x2();
GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m);
tmat4x2();
tmat4x2(tmat4x2<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat4x2(tmat4x2<T, Q> const & m);
tmat4x2(tmat4x2<T, Q> const & m);
GLM_FUNC_DECL explicit tmat4x2(
explicit tmat4x2(
ctor Null);
GLM_FUNC_DECL explicit tmat4x2(
explicit tmat4x2(
T const & x);
GLM_FUNC_DECL tmat4x2(
tmat4x2(
T const & x0, T const & y0,
T const & x1, T const & y1,
T const & x2, T const & y2,
T const & x3, T const & y3);
GLM_FUNC_DECL tmat4x2(
tmat4x2(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -85,14 +85,14 @@ namespace detail
typename X2, typename Y2,
typename X3, typename Y3,
typename X4, typename Y4>
GLM_FUNC_DECL tmat4x2(
tmat4x2(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3,
X4 const & x4, Y4 const & y4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x2(
tmat4x2(
tvec2<V1, P> const & v1,
tvec2<V2, P> const & v2,
tvec2<V3, P> const & v3,
@ -100,116 +100,116 @@ namespace detail
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m);
explicit tmat4x2(tmat4x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T, P> const & x);
explicit tmat4x2(tmat2x2<T, P> const & x);
explicit tmat4x2(tmat3x3<T, P> const & x);
explicit tmat4x2(tmat4x4<T, P> const & x);
explicit tmat4x2(tmat2x3<T, P> const & x);
explicit tmat4x2(tmat3x2<T, P> const & x);
explicit tmat4x2(tmat2x4<T, P> const & x);
explicit tmat4x2(tmat4x3<T, P> const & x);
explicit tmat4x2(tmat3x4<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x2<T, P>& operator= (tmat4x2<T, P> const & m);
tmat4x2<T, P>& operator= (tmat4x2<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator= (tmat4x2<U, P> const & m);
tmat4x2<T, P>& operator= (tmat4x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator+= (U s);
tmat4x2<T, P>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator+= (tmat4x2<U, P> const & m);
tmat4x2<T, P>& operator+= (tmat4x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator-= (U s);
tmat4x2<T, P>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator-= (tmat4x2<U, P> const & m);
tmat4x2<T, P>& operator-= (tmat4x2<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator*= (U s);
tmat4x2<T, P>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T, P>& operator/= (U s);
tmat4x2<T, P>& operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat4x2<T, P> & operator++ ();
GLM_FUNC_DECL tmat4x2<T, P> & operator-- ();
GLM_FUNC_DECL tmat4x2<T, P> operator++(int);
GLM_FUNC_DECL tmat4x2<T, P> operator--(int);
tmat4x2<T, P> & operator++ ();
tmat4x2<T, P> & operator-- ();
tmat4x2<T, P> operator++(int);
tmat4x2<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator+ (
tmat4x2<T, P> operator+ (
tmat4x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator+ (
tmat4x2<T, P> operator+ (
tmat4x2<T, P> const & m1,
tmat4x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator- (
tmat4x2<T, P> operator- (
tmat4x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator- (
tmat4x2<T, P> operator- (
tmat4x2<T, P> const & m1,
tmat4x2<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> operator* (
tmat4x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> operator* (
T const & s,
tmat4x2<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat4x2<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat4x2<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat3x2<T, P> operator* (
tmat3x2<T, P> operator* (
tmat4x2<T, P> const & m1,
tmat3x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator* (
tmat4x2<T, P> operator* (
tmat4x2<T, P> const & m1,
tmat4x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
tmat4x3<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator/ (
tmat4x2<T, P> operator/ (
tmat4x2<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> operator/ (
tmat4x2<T, P> operator/ (
T const & s,
tmat4x2<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x2<T, P> const operator-(
tmat4x2<T, P> const operator-(
tmat4x2<T, P> const & m);
}//namespace detail

94
deps/glm/detail/type_mat4x3.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat4x3<T, P> type;
typedef tmat3x4<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
private:
// Data
@ -57,21 +57,21 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat4x3();
GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m);
tmat4x3();
tmat4x3(tmat4x3<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat4x3(tmat4x3<T, Q> const & m);
tmat4x3(tmat4x3<T, Q> const & m);
GLM_FUNC_DECL explicit tmat4x3(
explicit tmat4x3(
ctor Null);
GLM_FUNC_DECL explicit tmat4x3(
explicit tmat4x3(
T const & x);
GLM_FUNC_DECL tmat4x3(
tmat4x3(
T const & x0, T const & y0, T const & z0,
T const & x1, T const & y1, T const & z1,
T const & x2, T const & y2, T const & z2,
T const & x3, T const & y3, T const & z3);
GLM_FUNC_DECL tmat4x3(
tmat4x3(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -85,14 +85,14 @@ namespace detail
typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3,
typename X4, typename Y4, typename Z4>
GLM_FUNC_DECL tmat4x3(
tmat4x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3,
X4 const & x4, Y4 const & y4, Z4 const & z4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x3(
tmat4x3(
tvec3<V1, P> const & v1,
tvec3<V2, P> const & v2,
tvec3<V3, P> const & v3,
@ -100,116 +100,116 @@ namespace detail
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m);
explicit tmat4x3(tmat4x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x);
explicit tmat4x3(tmat2x2<T, P> const & x);
explicit tmat4x3(tmat3x3<T, P> const & x);
explicit tmat4x3(tmat4x4<T, P> const & x);
explicit tmat4x3(tmat2x3<T, P> const & x);
explicit tmat4x3(tmat3x2<T, P> const & x);
explicit tmat4x3(tmat2x4<T, P> const & x);
explicit tmat4x3(tmat4x2<T, P> const & x);
explicit tmat4x3(tmat3x4<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x3<T, P> & operator= (tmat4x3<T, P> const & m);
tmat4x3<T, P> & operator= (tmat4x3<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator= (tmat4x3<U, P> const & m);
tmat4x3<T, P> & operator= (tmat4x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator+= (U s);
tmat4x3<T, P> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator+= (tmat4x3<U, P> const & m);
tmat4x3<T, P> & operator+= (tmat4x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator-= (U s);
tmat4x3<T, P> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator-= (tmat4x3<U, P> const & m);
tmat4x3<T, P> & operator-= (tmat4x3<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator*= (U s);
tmat4x3<T, P> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T, P> & operator/= (U s);
tmat4x3<T, P> & operator/= (U s);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat4x3<T, P> & operator++ ();
GLM_FUNC_DECL tmat4x3<T, P> & operator-- ();
GLM_FUNC_DECL tmat4x3<T, P> operator++(int);
GLM_FUNC_DECL tmat4x3<T, P> operator--(int);
tmat4x3<T, P> & operator++ ();
tmat4x3<T, P> & operator-- ();
tmat4x3<T, P> operator++(int);
tmat4x3<T, P> operator--(int);
};
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator+ (
tmat4x3<T, P> operator+ (
tmat4x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator+ (
tmat4x3<T, P> operator+ (
tmat4x3<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator- (
tmat4x3<T, P> operator- (
tmat4x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator- (
tmat4x3<T, P> operator- (
tmat4x3<T, P> const & m1,
tmat4x3<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> operator* (
tmat4x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> operator* (
T const & s,
tmat4x3<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat4x3<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat4x3<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat2x3<T, P> operator* (
tmat2x3<T, P> operator* (
tmat4x3<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x3<T, P> operator* (
tmat3x3<T, P> operator* (
tmat4x3<T, P> const & m1,
tmat3x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator* (
tmat4x3<T, P> operator* (
tmat4x3<T, P> const & m1,
tmat4x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator/ (
tmat4x3<T, P> operator/ (
tmat4x3<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> operator/ (
tmat4x3<T, P> operator/ (
T const & s,
tmat4x3<T, P> const & m);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x3<T, P> const operator- (
tmat4x3<T, P> const operator- (
tmat4x3<T, P> const & m);
}//namespace detail

110
deps/glm/detail/type_mat4x4.hpp vendored
View File

@ -49,7 +49,7 @@ namespace detail
typedef tmat4x4<T, P> type;
typedef tmat4x4<T, P> transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
template <typename U, precision Q>
friend tvec4<U, Q> operator/(tmat4x4<U, Q> const & m, tvec4<U, Q> const & v);
@ -62,21 +62,21 @@ namespace detail
public:
// Constructors
GLM_FUNC_DECL tmat4x4();
GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m);
tmat4x4();
tmat4x4(tmat4x4<T, P> const & m);
template <precision Q>
GLM_FUNC_DECL tmat4x4(tmat4x4<T, Q> const & m);
tmat4x4(tmat4x4<T, Q> const & m);
GLM_FUNC_DECL explicit tmat4x4(
explicit tmat4x4(
ctor Null);
GLM_FUNC_DECL explicit tmat4x4(
explicit tmat4x4(
T const & x);
GLM_FUNC_DECL tmat4x4(
tmat4x4(
T const & x0, T const & y0, T const & z0, T const & w0,
T const & x1, T const & y1, T const & z1, T const & w1,
T const & x2, T const & y2, T const & z2, T const & w2,
T const & x3, T const & y3, T const & z3, T const & w3);
GLM_FUNC_DECL tmat4x4(
tmat4x4(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -90,14 +90,14 @@ namespace detail
typename X2, typename Y2, typename Z2, typename W2,
typename X3, typename Y3, typename Z3, typename W3,
typename X4, typename Y4, typename Z4, typename W4>
GLM_FUNC_DECL tmat4x4(
tmat4x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x4(
tmat4x4(
tvec4<V1, P> const & v1,
tvec4<V2, P> const & v2,
tvec4<V3, P> const & v3,
@ -105,148 +105,148 @@ namespace detail
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m);
explicit tmat4x4(tmat4x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T, P> const & x);
explicit tmat4x4(tmat2x2<T, P> const & x);
explicit tmat4x4(tmat3x3<T, P> const & x);
explicit tmat4x4(tmat2x3<T, P> const & x);
explicit tmat4x4(tmat3x2<T, P> const & x);
explicit tmat4x4(tmat2x4<T, P> const & x);
explicit tmat4x4(tmat4x2<T, P> const & x);
explicit tmat4x4(tmat3x4<T, P> const & x);
explicit tmat4x4(tmat4x3<T, P> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](length_t i);
GLM_FUNC_DECL col_type const & operator[](length_t i) const;
col_type & operator[](length_t i);
col_type const & operator[](length_t i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x4<T, P> & operator= (tmat4x4<T, P> const & m);
tmat4x4<T, P> & operator= (tmat4x4<T, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator= (tmat4x4<U, P> const & m);
tmat4x4<T, P> & operator= (tmat4x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator+= (U s);
tmat4x4<T, P> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator+= (tmat4x4<U, P> const & m);
tmat4x4<T, P> & operator+= (tmat4x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator-= (U s);
tmat4x4<T, P> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator-= (tmat4x4<U, P> const & m);
tmat4x4<T, P> & operator-= (tmat4x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator*= (U s);
tmat4x4<T, P> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator*= (tmat4x4<U, P> const & m);
tmat4x4<T, P> & operator*= (tmat4x4<U, P> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator/= (U s);
tmat4x4<T, P> & operator/= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T, P> & operator/= (tmat4x4<U, P> const & m);
tmat4x4<T, P> & operator/= (tmat4x4<U, P> const & m);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tmat4x4<T, P> & operator++ ();
GLM_FUNC_DECL tmat4x4<T, P> & operator-- ();
GLM_FUNC_DECL tmat4x4<T, P> operator++(int);
GLM_FUNC_DECL tmat4x4<T, P> operator--(int);
tmat4x4<T, P> & operator++ ();
tmat4x4<T, P> & operator-- ();
tmat4x4<T, P> operator++(int);
tmat4x4<T, P> operator--(int);
};
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> compute_inverse_mat4(tmat4x4<T, P> const & m);
tmat4x4<T, P> compute_inverse_mat4(tmat4x4<T, P> const & m);
// Binary operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator+ (
tmat4x4<T, P> operator+ (
tmat4x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator+ (
tmat4x4<T, P> operator+ (
T const & s,
tmat4x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator+ (
tmat4x4<T, P> operator+ (
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator- (
tmat4x4<T, P> operator- (
tmat4x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator- (
tmat4x4<T, P> operator- (
T const & s,
tmat4x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator- (
tmat4x4<T, P> operator- (
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> operator* (
tmat4x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> operator* (
T const & s,
tmat4x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator* (
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>
GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator* (
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>
GLM_FUNC_DECL tmat2x4<T, P> operator* (
tmat2x4<T, P> operator* (
tmat4x4<T, P> const & m1,
tmat2x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat3x4<T, P> operator* (
tmat3x4<T, P> operator* (
tmat4x4<T, P> const & m1,
tmat3x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator* (
tmat4x4<T, P> operator* (
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator/ (
tmat4x4<T, P> operator/ (
tmat4x4<T, P> const & m,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator/ (
tmat4x4<T, P> operator/ (
T const & s,
tmat4x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator/ (
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>
GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator/ (
typename tmat4x4<T, P>::row_type operator/ (
typename tmat4x4<T, P>::col_type & v,
tmat4x4<T, P> const & m);
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> operator/ (
tmat4x4<T, P> operator/ (
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2);
// Unary constant operators
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> const operator- (
tmat4x4<T, P> const operator- (
tmat4x4<T, P> const & m);
}//namespace detail

144
deps/glm/detail/type_vec1.hpp vendored
View File

@ -58,7 +58,7 @@ namespace detail
//////////////////////////////////////
// Helper
GLM_FUNC_DECL length_t length() const;
length_t length() const;
//////////////////////////////////////
// Data
@ -68,23 +68,23 @@ namespace detail
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL T & operator[](length_t i);
GLM_FUNC_DECL T const & operator[](length_t i) const;
T & operator[](length_t i);
T const & operator[](length_t i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec1();
GLM_FUNC_DECL tvec1(tvec1<T, P> const & v);
tvec1();
tvec1(tvec1<T, P> const & v);
template <precision Q>
GLM_FUNC_DECL tvec1(tvec1<T, Q> const & v);
tvec1(tvec1<T, Q> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec1(
explicit tvec1(
ctor);
GLM_FUNC_DECL tvec1(
tvec1(
T const & s);
//////////////////////////////////////
@ -92,180 +92,180 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL explicit tvec1(tvec1<U, Q> const & v);
explicit tvec1(tvec1<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>
GLM_FUNC_DECL explicit tvec1(tvec2<U, Q> const & v);
explicit tvec1(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>
GLM_FUNC_DECL explicit tvec1(tvec3<U, Q> const & v);
explicit tvec1(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>
GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v);
explicit tvec1(tvec4<U, Q> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec1<T, P> & operator= (tvec1<T, P> const & v);
tvec1<T, P> & operator= (tvec1<T, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator= (tvec1<U, P> const & v);
tvec1<T, P> & operator= (tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator+=(U const & s);
tvec1<T, P> & operator+=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator+=(tvec1<U, P> const & v);
tvec1<T, P> & operator+=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator-=(U const & s);
tvec1<T, P> & operator-=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator-=(tvec1<U, P> const & v);
tvec1<T, P> & operator-=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator*=(U const & s);
tvec1<T, P> & operator*=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator*=(tvec1<U, P> const & v);
tvec1<T, P> & operator*=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator/=(U const & s);
tvec1<T, P> & operator/=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator/=(tvec1<U, P> const & v);
tvec1<T, P> & operator/=(tvec1<U, P> const & v);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tvec1<T, P> & operator++();
GLM_FUNC_DECL tvec1<T, P> & operator--();
GLM_FUNC_DECL tvec1<T, P> operator++(int);
GLM_FUNC_DECL tvec1<T, P> operator--(int);
tvec1<T, P> & operator++();
tvec1<T, P> & operator--();
tvec1<T, P> operator++(int);
tvec1<T, P> operator--(int);
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator%=(U const & s);
tvec1<T, P> & operator%=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator%=(tvec1<U, P> const & v);
tvec1<T, P> & operator%=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator&=(U const & s);
tvec1<T, P> & operator&=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator&=(tvec1<U, P> const & v);
tvec1<T, P> & operator&=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator|=(U const & s);
tvec1<T, P> & operator|=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator|=(tvec1<U, P> const & v);
tvec1<T, P> & operator|=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator^=(U const & s);
tvec1<T, P> & operator^=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator^=(tvec1<U, P> const & v);
tvec1<T, P> & operator^=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator<<=(U const & s);
tvec1<T, P> & operator<<=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator<<=(tvec1<U, P> const & v);
tvec1<T, P> & operator<<=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator>>=(U const & s);
tvec1<T, P> & operator>>=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
};
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator+(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator+(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator+(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator+(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator-(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator-(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator-(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator- (tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator- (tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator*(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator*(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator*(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator*(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator*(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator/(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator/(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator/(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v);
tvec1<T, P> operator-(tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator%(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator%(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator%(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator%(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator&(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator&(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator&(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator&(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator&(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator|(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator|(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator|(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator|(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator|(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator^(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator^(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator^(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator^(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator^(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator<<(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator<<(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator<<(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator<<(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator<<(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v, T const & s);
tvec1<T, P> operator>>(tvec1<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator>>(T const & s, tvec1<T, P> const & v);
tvec1<T, P> operator>>(T const & s, tvec1<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator>>(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
tvec1<T, P> operator>>(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
tvec1<T, P> operator~(tvec1<T, P> const & v);
}//namespace detail
}//namespace glm

144
deps/glm/detail/type_vec2.hpp vendored
View File

@ -59,7 +59,7 @@ namespace detail
//////////////////////////////////////
// Helper
GLM_FUNC_DECL length_t length() const;
length_t length() const;
//////////////////////////////////////
// Data
@ -93,25 +93,25 @@ namespace detail
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL T & operator[](length_t i);
GLM_FUNC_DECL T const & operator[](length_t i) const;
T & operator[](length_t i);
T const & operator[](length_t i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec2();
GLM_FUNC_DECL tvec2(tvec2<T, P> const & v);
tvec2();
tvec2(tvec2<T, P> const & v);
template <precision Q>
GLM_FUNC_DECL tvec2(tvec2<T, Q> const & v);
tvec2(tvec2<T, Q> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec2(
explicit tvec2(
ctor);
GLM_FUNC_DECL explicit tvec2(
explicit tvec2(
T const & s);
GLM_FUNC_DECL tvec2(
tvec2(
T const & s1,
T const & s2);
@ -120,7 +120,7 @@ namespace detail
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1>
GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)
tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)
{
*this = that();
}
@ -131,7 +131,7 @@ namespace detail
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V>
GLM_FUNC_DECL tvec2(
tvec2(
U const & x,
V const & y);
@ -140,170 +140,170 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL tvec2(tvec2<U, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
explicit tvec2(tvec4<U, Q> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec2<T, P> & operator= (tvec2<T, P> const & v);
tvec2<T, P> & operator= (tvec2<T, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator= (tvec2<U, P> const & v);
tvec2<T, P> & operator= (tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator+=(U s);
tvec2<T, P> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator+=(tvec2<U, P> const & v);
tvec2<T, P> & operator+=(tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator-=(U s);
tvec2<T, P> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator-=(tvec2<U, P> const & v);
tvec2<T, P> & operator-=(tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator*=(U s);
tvec2<T, P> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator*=(tvec2<U, P> const & v);
tvec2<T, P> & operator*=(tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator/=(U s);
tvec2<T, P> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator/=(tvec2<U, P> const & v);
tvec2<T, P> & operator/=(tvec2<U, P> const & v);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tvec2<T, P> & operator++();
GLM_FUNC_DECL tvec2<T, P> & operator--();
GLM_FUNC_DECL tvec2<T, P> operator++(int);
GLM_FUNC_DECL tvec2<T, P> operator--(int);
tvec2<T, P> & operator++();
tvec2<T, P> & operator--();
tvec2<T, P> operator++(int);
tvec2<T, P> operator--(int);
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator%= (U s);
tvec2<T, P> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator%= (tvec2<U, P> const & v);
tvec2<T, P> & operator%= (tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator&= (U s);
tvec2<T, P> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator&= (tvec2<U, P> const & v);
tvec2<T, P> & operator&= (tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator|= (U s);
tvec2<T, P> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator|= (tvec2<U, P> const & v);
tvec2<T, P> & operator|= (tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator^= (U s);
tvec2<T, P> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator^= (tvec2<U, P> const & v);
tvec2<T, P> & operator^= (tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator<<=(U s);
tvec2<T, P> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator<<=(tvec2<U, P> const & v);
tvec2<T, P> & operator<<=(tvec2<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator>>=(U s);
tvec2<T, P> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
};
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator+(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator+(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator+(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator+(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator-(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator-(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator-(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator- (tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator- (tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator*(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator*(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator*(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator*(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator/(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator/(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator/(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator/(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v);
tvec2<T, P> operator-(tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator%(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator%(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator%(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator%(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator&(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator&(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator&(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator&(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator|(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator|(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator|(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator|(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator^(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator^(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator^(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator^(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator<<(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator<<(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator<<(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator<<(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v, T const & s);
tvec2<T, P> operator>>(tvec2<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator>>(T const & s, tvec2<T, P> const & v);
tvec2<T, P> operator>>(T const & s, tvec2<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
tvec2<T, P> operator>>(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
tvec2<T, P> operator~(tvec2<T, P> const & v);
}//namespace detail
}//namespace glm

150
deps/glm/detail/type_vec3.hpp vendored
View File

@ -59,7 +59,7 @@ namespace detail
//////////////////////////////////////
// Helper
GLM_FUNC_DECL length_t length() const;
length_t length() const;
//////////////////////////////////////
// Data
@ -94,25 +94,25 @@ namespace detail
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL T & operator[](length_t i);
GLM_FUNC_DECL T const & operator[](length_t i) const;
T & operator[](length_t i);
T const & operator[](length_t i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec3();
GLM_FUNC_DECL tvec3(tvec3<T, P> const & v);
tvec3();
tvec3(tvec3<T, P> const & v);
template <precision Q>
GLM_FUNC_DECL tvec3(tvec3<T, Q> const & v);
tvec3(tvec3<T, Q> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec3(
explicit tvec3(
ctor);
GLM_FUNC_DECL explicit tvec3(
explicit tvec3(
T const & s);
GLM_FUNC_DECL tvec3(
tvec3(
T const & s1,
T const & s2,
T const & s3);
@ -122,7 +122,7 @@ namespace detail
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V, typename W>
GLM_FUNC_DECL tvec3(
tvec3(
U const & x,
V const & y,
W const & z);
@ -132,35 +132,35 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, precision Q>
GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & v, B const & s);
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>
GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec3(tvec3<U, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
explicit tvec3(tvec4<U, Q> const & v);
//////////////////////////////////////
// Swizzle constructors
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & that)
tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & that)
{
*this = that();
}
template <int E0, int E1>
GLM_FUNC_DECL tvec3(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & s)
tvec3(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & s)
{
*this = tvec3<T, P>(v(), s);
}
template <int E0, int E1>
GLM_FUNC_DECL tvec3(T const & s, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
tvec3(T const & s, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
{
*this = tvec3<T, P>(s, v());
}
@ -169,159 +169,159 @@ namespace detail
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec3<T, P> & operator= (tvec3<T, P> const & v);
tvec3<T, P> & operator= (tvec3<T, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator= (tvec3<U, P> const & v);
tvec3<T, P> & operator= (tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator+=(U s);
tvec3<T, P> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator+=(tvec3<U, P> const & v);
tvec3<T, P> & operator+=(tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator-=(U s);
tvec3<T, P> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator-=(tvec3<U, P> const & v);
tvec3<T, P> & operator-=(tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator*=(U s);
tvec3<T, P> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator*=(tvec3<U, P> const & v);
tvec3<T, P> & operator*=(tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator/=(U s);
tvec3<T, P> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec3<U, P> const & v);
tvec3<T, P> & operator/=(tvec3<U, P> const & v);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tvec3<T, P> & operator++();
GLM_FUNC_DECL tvec3<T, P> & operator--();
GLM_FUNC_DECL tvec3<T, P> operator++(int);
GLM_FUNC_DECL tvec3<T, P> operator--(int);
tvec3<T, P> & operator++();
tvec3<T, P> & operator--();
tvec3<T, P> operator++(int);
tvec3<T, P> operator--(int);
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator%= (U s);
tvec3<T, P> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator%= (tvec3<U, P> const & v);
tvec3<T, P> & operator%= (tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator&= (U s);
tvec3<T, P> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator&= (tvec3<U, P> const & v);
tvec3<T, P> & operator&= (tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator|= (U s);
tvec3<T, P> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator|= (tvec3<U, P> const & v);
tvec3<T, P> & operator|= (tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator^= (U s);
tvec3<T, P> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator^= (tvec3<U, P> const & v);
tvec3<T, P> & operator^= (tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator<<=(U s);
tvec3<T, P> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator<<=(tvec3<U, P> const & v);
tvec3<T, P> & operator<<=(tvec3<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator>>=(U s);
tvec3<T, P> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
};
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator+(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator+(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator+(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator+(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator-(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator-(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator-(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator- (tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator- (tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator*(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator*(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator*(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator*(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator/(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator/(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator/(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v);
tvec3<T, P> operator-(tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator%(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator%(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator%(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator%(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator&(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator&(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator&(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator&(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator|(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator|(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator|(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator|(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator^(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator^(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator^(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator^(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator<<(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator<<(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator<<(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator<<(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v, T const & s);
tvec3<T, P> operator>>(tvec3<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator>>(T const & s, tvec3<T, P> const & v);
tvec3<T, P> operator>>(T const & s, tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
tvec3<T, P> operator>>(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
tvec3<T, P> operator~(tvec3<T, P> const & v);
}//namespace detail
}//namespace glm

168
deps/glm/detail/type_vec4.hpp vendored
View File

@ -60,7 +60,7 @@ namespace detail
//////////////////////////////////////
// Helper
GLM_FUNC_DECL length_t length() const;
length_t length() const;
//////////////////////////////////////
// Data
@ -96,25 +96,25 @@ namespace detail
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL T & operator[](length_t i);
GLM_FUNC_DECL T const & operator[](length_t i) const;
T & operator[](length_t i);
T const & operator[](length_t i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec4();
GLM_FUNC_DECL tvec4(type const & v);
tvec4();
tvec4(type const & v);
template <precision Q>
GLM_FUNC_DECL tvec4(tvec4<T, Q> const & v);
tvec4(tvec4<T, Q> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec4(
explicit tvec4(
ctor);
GLM_FUNC_DECL explicit tvec4(
explicit tvec4(
T const & s);
GLM_FUNC_DECL tvec4(
tvec4(
T const & s0,
T const & s1,
T const & s2,
@ -125,7 +125,7 @@ namespace detail
/// 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>
GLM_FUNC_DECL tvec4(
tvec4(
A const & x,
B const & y,
C const & z,
@ -136,68 +136,68 @@ namespace detail
//! 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>
GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v, B const & s1, C const & s2);
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>
GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2);
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>
GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & v, B const & s);
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>
GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B, Q> const & v);
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>
GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> const & v2);
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>
GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
explicit tvec4(tvec4<U, Q> const & v);
//////////////////////////////////////
// Swizzle constructors
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const & that)
tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const & that)
{
*this = that();
}
template <int E0, int E1, int F0, int F1>
GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, _swizzle<2, T, P, tvec2<T, P>, F0, F1, -1, -2> const & u)
tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, _swizzle<2, T, P, tvec2<T, P>, F0, F1, -1, -2> const & u)
{
*this = tvec4<T, P>(v(), u());
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, T const & y, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
tvec4(T const & x, T const & y, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
{
*this = tvec4<T, P>(x, y, v());
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & w)
tvec4(T const & x, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & w)
{
*this = tvec4<T, P>(x, v(), w);
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & z, T const & w)
tvec4(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & z, T const & w)
{
*this = tvec4<T, P>(v(), z, w);
}
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v, T const & w)
tvec4(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v, T const & w)
{
*this = tvec4<T, P>(v(), w);
}
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(T const & x, _swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v)
tvec4(T const & x, _swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v)
{
*this = tvec4<T, P>(x, v());
}
@ -206,165 +206,165 @@ namespace detail
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<T, P> const & v);
tvec4<T, P> & operator= (tvec4<T, P> const & v);
template <typename U, precision Q>
GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<U, Q> const & v);
tvec4<T, P> & operator= (tvec4<U, Q> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(U s);
tvec4<T, P> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v);
tvec4<T, P> & operator+=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(U s);
tvec4<T, P> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v);
tvec4<T, P> & operator-=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(U s);
tvec4<T, P> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const & v);
tvec4<T, P> & operator*=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(U s);
tvec4<T, P> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<U, P> const & v);
tvec4<T, P> & operator/=(tvec4<U, P> const & v);
//////////////////////////////////////
// Increment and decrement operators
GLM_FUNC_DECL tvec4<T, P> & operator++();
GLM_FUNC_DECL tvec4<T, P> & operator--();
GLM_FUNC_DECL tvec4<T, P> operator++(int);
GLM_FUNC_DECL tvec4<T, P> operator--(int);
tvec4<T, P> & operator++();
tvec4<T, P> & operator--();
tvec4<T, P> operator++(int);
tvec4<T, P> operator--(int);
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%= (U s);
tvec4<T, P> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%= (tvec4<U, P> const & v);
tvec4<T, P> & operator%= (tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&= (U s);
tvec4<T, P> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&= (tvec4<U, P> const & v);
tvec4<T, P> & operator&= (tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|= (U s);
tvec4<T, P> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|= (tvec4<U, P> const & v);
tvec4<T, P> & operator|= (tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^= (U s);
tvec4<T, P> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^= (tvec4<U, P> const & v);
tvec4<T, P> & operator^= (tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(U s);
tvec4<T, P> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(U s);
tvec4<T, P> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
};
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator+(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator+(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator-(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator-(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator- (tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator- (tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator*(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator*(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator/(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator/(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v);
tvec4<T, P> operator-(tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator%(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator%(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator&(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator&(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator|(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator|(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator^(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator^(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator<<(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator<<(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, T const & s);
tvec4<T, P> operator>>(tvec4<T, P> const & v, T const & s);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(T const & s, tvec4<T, P> const & v);
tvec4<T, P> operator>>(T const & s, tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
tvec4<T, P> operator>>(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
tvec4<T, P> operator~(tvec4<T, P> const & v);
}//namespace detail
}//namespace glm

50
deps/glm/gtc/constants.hpp vendored
View File

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

8
deps/glm/gtc/epsilon.hpp vendored
View File

@ -58,7 +58,7 @@ namespace glm
///
/// @see gtc_epsilon
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> epsilonEqual(
vecType<bool, P> epsilonEqual(
vecType<T, P> const & x,
vecType<T, P> const & y,
T const & epsilon);
@ -68,7 +68,7 @@ namespace glm
///
/// @see gtc_epsilon
template <typename genType>
GLM_FUNC_DECL bool epsilonEqual(
bool epsilonEqual(
genType const & x,
genType const & y,
genType const & epsilon);
@ -78,7 +78,7 @@ namespace glm
///
/// @see gtc_epsilon
template <typename genType>
GLM_FUNC_DECL typename genType::boolType epsilonNotEqual(
typename genType::boolType epsilonNotEqual(
genType const & x,
genType const & y,
typename genType::value_type const & epsilon);
@ -88,7 +88,7 @@ namespace glm
///
/// @see gtc_epsilon
template <typename genType>
GLM_FUNC_DECL bool epsilonNotEqual(
bool epsilonNotEqual(
genType const & x,
genType const & y,
genType const & epsilon);

8
deps/glm/gtc/matrix_access.hpp vendored
View File

@ -52,14 +52,14 @@ namespace glm
/// Get a specific row of a matrix.
/// @see gtc_matrix_access
template <typename genType>
GLM_FUNC_DECL typename genType::row_type row(
typename genType::row_type row(
genType const & m,
length_t const & index);
/// Set a specific row to a matrix.
/// @see gtc_matrix_access
template <typename genType>
GLM_FUNC_DECL genType row(
genType row(
genType const & m,
length_t const & index,
typename genType::row_type const & x);
@ -67,14 +67,14 @@ namespace glm
/// Get a specific column of a matrix.
/// @see gtc_matrix_access
template <typename genType>
GLM_FUNC_DECL typename genType::col_type column(
typename genType::col_type column(
genType const & m,
length_t const & index);
/// Set a specific column to a matrix.
/// @see gtc_matrix_access
template <typename genType>
GLM_FUNC_DECL genType column(
genType column(
genType const & m,
length_t const & index,
typename genType::col_type const & x);

4
deps/glm/gtc/matrix_inverse.hpp vendored
View File

@ -55,7 +55,7 @@ namespace glm
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template <typename genType>
GLM_FUNC_DECL genType affineInverse(genType const & m);
genType affineInverse(genType const & m);
/// Compute the inverse transpose of a matrix.
///
@ -63,7 +63,7 @@ namespace glm
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template <typename genType>
GLM_FUNC_DECL typename genType::value_type inverseTranspose(
typename genType::value_type inverseTranspose(
genType const & m);
/// @}

28
deps/glm/gtc/matrix_transform.hpp vendored
View File

@ -82,7 +82,7 @@ namespace glm
/// @see - translate(detail::tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - translate(detail::tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> translate(
detail::tmat4x4<T, P> translate(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v);
@ -98,7 +98,7 @@ namespace glm
/// @see - rotate(detail::tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, detail::tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rotate(
detail::tmat4x4<T, P> rotate(
detail::tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & axis);
@ -114,7 +114,7 @@ namespace glm
/// @see - scale(detail::tmat4x4<T, P> const & m, T x, T y, T z)
/// @see - scale(detail::tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> scale(
detail::tmat4x4<T, P> scale(
detail::tmat4x4<T, P> const & m,
detail::tvec3<T, P> const & v);
@ -130,7 +130,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
detail::tmat4x4<T, defaultp> ortho(
T const & left,
T const & right,
T const & bottom,
@ -148,7 +148,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
detail::tmat4x4<T, defaultp> ortho(
T const & left,
T const & right,
T const & bottom,
@ -165,7 +165,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> frustum(
detail::tmat4x4<T, P> frustum(
T const & left,
T const & right,
T const & bottom,
@ -182,7 +182,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> perspective(
detail::tmat4x4<T, P> perspective(
T const & fovy,
T const & aspect,
T const & near,
@ -198,7 +198,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> perspectiveFov(
detail::tmat4x4<T, P> perspectiveFov(
T const & fov,
T const & width,
T const & height,
@ -213,7 +213,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> infinitePerspective(
detail::tmat4x4<T, P> infinitePerspective(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@ -224,7 +224,7 @@ namespace glm
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
/// @see gtc_matrix_transform
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> tweakedInfinitePerspective(
detail::tmat4x4<T, P> tweakedInfinitePerspective(
T fovy, T aspect, T near);
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
@ -237,7 +237,7 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, typename U, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> project(
detail::tvec3<T, P> project(
detail::tvec3<T, P> const & obj,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
@ -253,7 +253,7 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, typename U, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> unProject(
detail::tvec3<T, P> unProject(
detail::tvec3<T, P> const & win,
detail::tmat4x4<T, P> const & model,
detail::tmat4x4<T, P> const & proj,
@ -268,7 +268,7 @@ namespace glm
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template <typename T, precision P, typename U>
GLM_FUNC_DECL detail::tmat4x4<T, P> pickMatrix(
detail::tmat4x4<T, P> pickMatrix(
detail::tvec2<T, P> const & center,
detail::tvec2<T, P> const & delta,
detail::tvec4<U, P> const & viewport);
@ -281,7 +281,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> lookAt(
detail::tmat4x4<T, P> lookAt(
detail::tvec3<T, P> const & eye,
detail::tvec3<T, P> const & center,
detail::tvec3<T, P> const & up);

6
deps/glm/gtc/noise.hpp vendored
View File

@ -57,20 +57,20 @@ namespace glm
/// Classic perlin noise.
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T perlin(
T perlin(
vecType<T, P> const & p);
/// Periodic perlin noise.
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T perlin(
T perlin(
vecType<T, P> const & p,
vecType<T, P> const & rep);
/// Simplex noise.
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T simplex(
T simplex(
vecType<T, P> const & p);
/// @}

60
deps/glm/gtc/packing.hpp vendored
View File

@ -62,7 +62,7 @@ namespace glm
/// @see uint32 packUnorm4x8(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint8 packUnorm1x8(float const & v);
uint8 packUnorm1x8(float const & v);
/// Convert a single 8-bit integer to a normalized floating-point value.
///
@ -74,7 +74,7 @@ namespace glm
/// @see vec4 unpackUnorm4x8(uint32 p)
/// @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>
GLM_FUNC_DECL float unpackUnorm1x8(uint8 const & p);
float unpackUnorm1x8(uint8 const & p);
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -90,7 +90,7 @@ namespace glm
/// @see uint32 packUnorm4x8(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const & v);
uint16 packUnorm2x8(vec2 const & v);
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
@ -106,7 +106,7 @@ namespace glm
/// @see vec4 unpackUnorm4x8(uint32 p)
/// @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>
GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 const & p);
vec2 unpackUnorm2x8(uint16 const & p);
/// First, converts the normalized floating-point value v into 8-bit integer value.
/// Then, the results are packed into the returned 8-bit unsigned integer.
@ -119,7 +119,7 @@ namespace glm
/// @see uint32 packSnorm4x8(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint8 packSnorm1x8(float const & s);
uint8 packSnorm1x8(float const & s);
/// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@ -132,7 +132,7 @@ namespace glm
/// @see vec4 unpackSnorm4x8(uint32 p)
/// @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>
GLM_FUNC_DECL float unpackSnorm1x8(uint8 const & p);
float unpackSnorm1x8(uint8 const & p);
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -148,7 +148,7 @@ namespace glm
/// @see uint32 packSnorm4x8(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const & v);
uint16 packSnorm2x8(vec2 const & v);
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
@ -164,7 +164,7 @@ namespace glm
/// @see vec4 unpackSnorm4x8(uint32 p)
/// @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>
GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 const & p);
vec2 unpackSnorm2x8(uint16 const & p);
/// First, converts the normalized floating-point value v into a 16-bit integer value.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -177,7 +177,7 @@ namespace glm
/// @see uint64 packSnorm4x16(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint16 packUnorm1x16(float const & v);
uint16 packUnorm1x16(float const & v);
/// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@ -190,7 +190,7 @@ namespace glm
/// @see vec4 unpackUnorm4x16(uint64 p)
/// @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>
GLM_FUNC_DECL float unpackUnorm1x16(uint16 const & p);
float unpackUnorm1x16(uint16 const & p);
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
/// Then, the results are packed into the returned 64-bit unsigned integer.
@ -206,7 +206,7 @@ namespace glm
/// @see uint32 packUnorm2x16(vec2 const & v)
/// @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>
GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const & v);
uint64 packUnorm4x16(vec4 const & v);
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -222,7 +222,7 @@ namespace glm
/// @see vec2 unpackUnorm2x16(uint32 p)
/// @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>
GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 const & p);
vec4 unpackUnorm4x16(uint64 const & p);
/// First, converts the normalized floating-point value v into 16-bit integer value.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -235,7 +235,7 @@ namespace glm
/// @see uint64 packSnorm4x16(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint16 packSnorm1x16(float const & v);
uint16 packSnorm1x16(float const & v);
/// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned scalar.
@ -248,7 +248,7 @@ namespace glm
/// @see vec4 unpackSnorm4x16(uint64 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm1x16.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>
GLM_FUNC_DECL float unpackSnorm1x16(uint16 const & p);
float unpackSnorm1x16(uint16 const & p);
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
/// Then, the results are packed into the returned 64-bit unsigned integer.
@ -264,7 +264,7 @@ namespace glm
/// @see uint32 packSnorm2x16(vec2 const & v)
/// @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>
GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const & v);
uint64 packSnorm4x16(vec4 const & v);
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -280,7 +280,7 @@ namespace glm
/// @see vec2 unpackSnorm2x16(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.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>
GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 const & p);
vec4 unpackSnorm4x16(uint64 const & p);
/// Returns an unsigned integer obtained by converting the components of a floating-point scalar
/// to the 16-bit floating-point representation found in the OpenGL Specification,
@ -291,7 +291,7 @@ namespace glm
/// @see uint64 packHalf4x16(vec4 const & v)
/// @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>
GLM_FUNC_DECL uint16 packHalf1x16(float const & v);
uint16 packHalf1x16(float const & v);
/// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value,
/// interpreted as a 16-bit floating-point number according to the OpenGL Specification,
@ -302,7 +302,7 @@ namespace glm
/// @see vec4 unpackHalf4x16(uint64 const & v)
/// @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>
GLM_FUNC_DECL float unpackHalf1x16(uint16 const & v);
float unpackHalf1x16(uint16 const & v);
/// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector
/// to the 16-bit floating-point representation found in the OpenGL Specification,
@ -315,7 +315,7 @@ namespace glm
/// @see uint32 packHalf2x16(vec2 const & v)
/// @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>
GLM_FUNC_DECL uint64 packHalf4x16(vec4 const & v);
uint64 packHalf4x16(vec4 const & v);
/// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values,
/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
@ -328,7 +328,7 @@ namespace glm
/// @see vec2 unpackHalf2x16(uint32 const & v)
/// @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>
GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 const & p);
vec4 unpackHalf4x16(uint64 const & p);
/// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector
/// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification,
@ -341,7 +341,7 @@ namespace glm
/// @see uint32 packSnorm3x10_1x2(vec4 const & v)
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see ivec4 unpackI3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const & v);
uint32 packI3x10_1x2(ivec4 const & v);
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers.
///
@ -352,7 +352,7 @@ namespace glm
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 const & p);
ivec4 unpackI3x10_1x2(uint32 const & p);
/// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector
/// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification,
@ -365,7 +365,7 @@ namespace glm
/// @see uint32 packSnorm3x10_1x2(vec4 const & v)
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see ivec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const & v);
uint32 packU3x10_1x2(uvec4 const & v);
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers.
///
@ -376,7 +376,7 @@ namespace glm
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 const & p);
uvec4 unpackU3x10_1x2(uint32 const & p);
/// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values.
@ -394,7 +394,7 @@ namespace glm
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const & v);
uint32 packSnorm3x10_1x2(vec4 const & v);
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -411,7 +411,7 @@ namespace glm
/// @see vec4 unpackUnorm3x10_1x2(uint32 const & p))
/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 const & p);
vec4 unpackSnorm3x10_1x2(uint32 const & p);
/// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values.
@ -429,7 +429,7 @@ namespace glm
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const & v);
uint32 packUnorm3x10_1x2(vec4 const & v);
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -446,7 +446,7 @@ namespace glm
/// @see vec4 unpackInorm3x10_1x2(uint32 const & p))
/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 const & p);
vec4 unpackUnorm3x10_1x2(uint32 const & p);
/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
@ -457,7 +457,7 @@ namespace glm
///
/// @see gtc_packing
/// @see vec3 unpackF2x11_1x10(uint32 const & p)
GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const & v);
uint32 packF2x11_1x10(vec3 const & v);
/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
/// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.
@ -467,7 +467,7 @@ namespace glm
///
/// @see gtc_packing
/// @see uint32 packF2x11_1x10(vec3 const & v)
GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 const & p);
vec3 unpackF2x11_1x10(uint32 const & p);
/// @}
}// namespace glm

102
deps/glm/gtc/quaternion.hpp vendored
View File

@ -64,17 +64,17 @@ namespace detail
public:
T x, y, z, w;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
// Constructors
GLM_FUNC_DECL tquat();
tquat();
template <typename U, precision Q>
GLM_FUNC_DECL explicit tquat(
explicit tquat(
tquat<U, Q> const & q);
GLM_FUNC_DECL tquat(
tquat(
T const & s,
tvec3<T, P> const & v);
GLM_FUNC_DECL tquat(
tquat(
T const & w,
T const & x,
T const & y,
@ -88,74 +88,74 @@ namespace detail
/// @param v A second normalized axis
/// @see gtc_quaternion
/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
GLM_FUNC_DECL explicit tquat(
explicit tquat(
detail::tvec3<T, P> const & u,
detail::tvec3<T, P> const & v);
/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
GLM_FUNC_DECL explicit tquat(
explicit tquat(
tvec3<T, P> const & eulerAngles);
GLM_FUNC_DECL explicit tquat(
explicit tquat(
tmat3x3<T, P> const & m);
GLM_FUNC_DECL explicit tquat(
explicit tquat(
tmat4x4<T, P> const & m);
// Accesses
GLM_FUNC_DECL T & operator[](length_t i);
GLM_FUNC_DECL T const & operator[](length_t i) const;
T & operator[](length_t i);
T const & operator[](length_t i) const;
// Operators
GLM_FUNC_DECL tquat<T, P> & operator+=(tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> & operator*=(tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> & operator*=(T const & s);
GLM_FUNC_DECL tquat<T, P> & operator/=(T const & s);
tquat<T, P> & operator+=(tquat<T, P> const & q);
tquat<T, P> & operator*=(tquat<T, P> const & q);
tquat<T, P> & operator*=(T const & s);
tquat<T, P> & operator/=(T const & s);
};
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator- (
detail::tquat<T, P> operator- (
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator+ (
detail::tquat<T, P> operator+ (
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
detail::tquat<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> operator* (
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> operator* (
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
detail::tquat<T, P> operator* (
detail::tquat<T, P> const & q,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator* (
detail::tquat<T, P> operator* (
T const & s,
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator/ (
detail::tquat<T, P> operator/ (
detail::tquat<T, P> const & q,
T const & s);
@ -168,21 +168,21 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T length(
T length(
detail::tquat<T, P> const & q);
/// Returns the normalized quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> normalize(
detail::tquat<T, P> normalize(
detail::tquat<T, P> const & q);
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
///
/// @see gtc_quaternion
template <typename T, precision P, template <typename, precision> class quatType>
GLM_FUNC_DECL T dot(
T dot(
quatType<T, P> const & x,
quatType<T, P> const & y);
@ -197,7 +197,7 @@ namespace detail
/// @see gtc_quaternion
/// @see - slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a)
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> mix(
detail::tquat<T, P> mix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
T const & a);
@ -211,7 +211,7 @@ namespace detail
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> lerp(
detail::tquat<T, P> lerp(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
T const & a);
@ -225,7 +225,7 @@ namespace detail
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> slerp(
detail::tquat<T, P> slerp(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
T const & a);
@ -234,14 +234,14 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> conjugate(
detail::tquat<T, P> conjugate(
detail::tquat<T, P> const & q);
/// Returns the q inverse.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> inverse(
detail::tquat<T, P> inverse(
detail::tquat<T, P> const & q);
/// Rotates a quaternion from a vector of 3 components axis and an angle.
@ -252,7 +252,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotate(
detail::tquat<T, P> rotate(
detail::tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & axis);
@ -262,66 +262,66 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> eulerAngles(
detail::tvec3<T, P> eulerAngles(
detail::tquat<T, P> const & x);
/// Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T roll(detail::tquat<T, P> const & x);
T roll(detail::tquat<T, P> const & x);
/// Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T pitch(detail::tquat<T, P> const & x);
T pitch(detail::tquat<T, P> const & x);
/// Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
///
/// @see gtx_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T yaw(detail::tquat<T, P> const & x);
T yaw(detail::tquat<T, P> const & x);
/// Converts a quaternion to a 3 * 3 matrix.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> mat3_cast(
detail::tmat3x3<T, P> mat3_cast(
detail::tquat<T, P> const & x);
/// Converts a quaternion to a 4 * 4 matrix.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> mat4_cast(
detail::tmat4x4<T, P> mat4_cast(
detail::tquat<T, P> const & x);
/// Converts a 3 * 3 matrix to a quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
detail::tquat<T, P> quat_cast(
detail::tmat3x3<T, P> const & x);
/// Converts a 4 * 4 matrix to a quaternion.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
detail::tquat<T, P> quat_cast(
detail::tmat4x4<T, P> const & x);
/// Returns the quaternion rotation angle.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL T angle(detail::tquat<T, P> const & x);
T angle(detail::tquat<T, P> const & x);
/// Returns the q rotation axis.
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> axis(
detail::tvec3<T, P> axis(
detail::tquat<T, P> const & x);
/// Build a quaternion from an angle and a normalized axis.
@ -331,7 +331,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> angleAxis(
detail::tquat<T, P> angleAxis(
T const & angle,
detail::tvec3<T, P> const & axis);
@ -341,7 +341,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> lessThan(
detail::tvec4<bool, P> lessThan(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
@ -351,7 +351,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> lessThanEqual(
detail::tvec4<bool, P> lessThanEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
@ -361,7 +361,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> greaterThan(
detail::tvec4<bool, P> greaterThan(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
@ -371,7 +371,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> greaterThanEqual(
detail::tvec4<bool, P> greaterThanEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
@ -381,7 +381,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> equal(
detail::tvec4<bool, P> equal(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);
@ -391,7 +391,7 @@ namespace detail
///
/// @see gtc_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> notEqual(
detail::tvec4<bool, P> notEqual(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y);

12
deps/glm/gtc/random.hpp vendored
View File

@ -60,7 +60,7 @@ namespace glm
/// @tparam genType Value type. Currently supported: half (not recommanded), float or double scalars and vectors.
/// @see gtc_random
template <typename genType>
GLM_FUNC_DECL genType linearRand(
genType linearRand(
genType const & Min,
genType const & Max);
@ -70,7 +70,7 @@ namespace glm
/// @param Deviation
/// @see gtc_random
template <typename genType>
GLM_FUNC_DECL genType gaussRand(
genType gaussRand(
genType const & Mean,
genType const & Deviation);
@ -79,7 +79,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> circularRand(
detail::tvec2<T, defaultp> circularRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
@ -87,7 +87,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> sphericalRand(
detail::tvec3<T, defaultp> sphericalRand(
T const & Radius);
/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
@ -95,7 +95,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> diskRand(
detail::tvec2<T, defaultp> diskRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
@ -103,7 +103,7 @@ namespace glm
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> ballRand(
detail::tvec3<T, defaultp> ballRand(
T const & Radius);
/// @}

24
deps/glm/gtc/reciprocal.hpp vendored
View File

@ -55,75 +55,75 @@ namespace glm
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType sec(genType const & angle);
genType sec(genType const & angle);
/// Cosecant function.
/// hypotenuse / opposite or 1 / sin(x)
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType csc(genType const & angle);
genType csc(genType const & angle);
/// Cotangent function.
/// adjacent / opposite or 1 / tan(x)
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType cot(genType const & angle);
genType cot(genType const & angle);
/// Inverse secant function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType asec(genType const & x);
genType asec(genType const & x);
/// Inverse cosecant function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acsc(genType const & x);
genType acsc(genType const & x);
/// Inverse cotangent function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acot(genType const & x);
genType acot(genType const & x);
/// Secant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType sech(genType const & angle);
genType sech(genType const & angle);
/// Cosecant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType csch(genType const & angle);
genType csch(genType const & angle);
/// Cotangent hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType coth(genType const & angle);
genType coth(genType const & angle);
/// Inverse secant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType asech(genType const & x);
genType asech(genType const & x);
/// Inverse cosecant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acsch(genType const & x);
genType acsch(genType const & x);
/// Inverse cotangent hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acoth(genType const & x);
genType acoth(genType const & x);
/// @}
}//namespace glm

34
deps/glm/gtc/type_ptr.hpp vendored
View File

@ -87,88 +87,88 @@ namespace glm
/// Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename genType>
GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const & vec);
typename genType::value_type const * value_ptr(genType const & vec);
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec2<T, defaultp> make_vec2(T const * const ptr);
detail::tvec2<T, defaultp> make_vec2(T const * const ptr);
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec3<T, defaultp> make_vec3(T const * const ptr);
detail::tvec3<T, defaultp> make_vec3(T const * const ptr);
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tvec4<T, defaultp> make_vec4(T const * const ptr);
detail::tvec4<T, defaultp> make_vec4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x2<T, defaultp> make_mat4x2(
detail::tmat4x2<T, defaultp> make_mat4x2(
T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr);
detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr);
detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr);
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr);
detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr);
/// Build a quaternion from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL detail::tquat<T, defaultp> make_quat(T const * const ptr);
detail::tquat<T, defaultp> make_quat(T const * const ptr);
/// @}
}//namespace glm

12
deps/glm/gtc/ulp.hpp vendored
View File

@ -56,32 +56,32 @@ namespace glm
/// Return the next ULP value(s) after the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType next_float(genType const & x);
genType next_float(genType const & x);
/// Return the previous ULP value(s) before the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType prev_float(genType const & x);
genType prev_float(genType const & x);
/// Return the value(s) ULP distance after the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance);
genType next_float(genType const & x, uint const & Distance);
/// Return the value(s) ULP distance before the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance);
genType prev_float(genType const & x, uint const & Distance);
/// Return the distance in the number of ULP between 2 scalars.
/// @see gtc_ulp
template <typename T>
GLM_FUNC_DECL uint float_distance(T const & x, T const & y);
uint float_distance(T const & x, T const & y);
/// Return the distance in the number of ULP between 2 vectors.
/// @see gtc_ulp
template<typename T, template<typename> class vecType>
GLM_FUNC_DECL vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
/// @}
}// namespace glm

12
deps/glm/gtx/associated_min_max.hpp vendored
View File

@ -53,14 +53,14 @@ namespace glm
/// Min comparison between 2 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
/// Min comparison between 3 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
@ -68,7 +68,7 @@ namespace glm
/// Min comparison between 4 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
@ -77,14 +77,14 @@ namespace glm
/// Max comparison between 2 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
/// Max comparison between 3 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
@ -92,7 +92,7 @@ namespace glm
/// Max comparison between 4 variables
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,

54
deps/glm/gtx/bit.hpp vendored
View File

@ -56,52 +56,52 @@ namespace glm
/// Build a mask of 'count' bits
/// @see gtx_bit
template <typename genIType>
GLM_FUNC_DECL genIType mask(genIType const & count);
genIType mask(genIType const & count);
//! Find the highest bit set to 1 in a integer variable and return its value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType highestBitValue(genType const & value);
genType highestBitValue(genType const & value);
//! Return true if the value is a power of two number.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL bool isPowerOfTwo(genType const & value);
bool isPowerOfTwo(genType const & value);
//! Return the power of two number which value is just higher the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoAbove(genType const & value);
genType powerOfTwoAbove(genType const & value);
//! Return the power of two number which value is just lower the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoBelow(genType const & value);
genType powerOfTwoBelow(genType const & value);
//! Return the power of two number which value is the closet to the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoNearest(genType const & value);
genType powerOfTwoNearest(genType const & value);
//! Revert all bits of any integer based type.
/// @see gtx_bit
template <typename genType>
GLM_DEPRECATED GLM_FUNC_DECL genType bitRevert(genType const & value);
GLM_DEPRECATED genType bitRevert(genType const & value);
//! Rotate all bits to the right.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType bitRotateRight(genType const & In, std::size_t Shift);
genType bitRotateRight(genType const & In, std::size_t Shift);
//! Rotate all bits to the left.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType bitRotateLeft(genType const & In, std::size_t Shift);
genType bitRotateLeft(genType const & In, std::size_t Shift);
//! Set to 1 a range of bits.
/// @see gtx_bit
template <typename genIUType>
GLM_FUNC_DECL genIUType fillBitfieldWithOne(
genIUType fillBitfieldWithOne(
genIUType const & Value,
int const & FromBit,
int const & ToBit);
@ -109,7 +109,7 @@ namespace glm
//! Set to 0 a range of bits.
/// @see gtx_bit
template <typename genIUType>
GLM_FUNC_DECL genIUType fillBitfieldWithZero(
genIUType fillBitfieldWithZero(
genIUType const & Value,
int const & FromBit,
int const & ToBit);
@ -119,112 +119,112 @@ namespace glm
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
int16 bitfieldInterleave(int8 x, int8 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
uint16 bitfieldInterleave(uint8 x, uint8 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
int32 bitfieldInterleave(int16 x, int16 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
uint32 bitfieldInterleave(uint16 x, uint16 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
int64 bitfieldInterleave(int32 x, int32 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
uint64 bitfieldInterleave(uint32 x, uint32 y);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
int32 bitfieldInterleave(int8 x, int8 y, int8 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
int64 bitfieldInterleave(int16 x, int16 y, int16 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
int64 bitfieldInterleave(int32 x, int32 y, int32 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
/// @}
} //namespace glm

43
deps/glm/gtx/bit.inl vendored
View File

@ -312,51 +312,14 @@ namespace glm
namespace detail
{
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
RET bitfieldInterleave(PARAM x, PARAM y);
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
/*
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y)
{
RET Result = 0;
for (int i = 0; i < sizeof(PARAM) * 8; i++)
Result |= (x & 1U << i) << i | (y & 1U << i) << (i + 1);
return Result;
}
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y, PARAM z)
{
RET Result = 0;
for (RET i = 0; i < sizeof(PARAM) * 8; i++)
{
Result |= ((RET(x) & (RET(1) << i)) << ((i << 1) + 0));
Result |= ((RET(y) & (RET(1) << i)) << ((i << 1) + 1));
Result |= ((RET(z) & (RET(1) << i)) << ((i << 1) + 2));
}
return Result;
}
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w)
{
RET Result = 0;
for (int i = 0; i < sizeof(PARAM) * 8; i++)
{
Result |= ((((RET(x) >> i) & RET(1))) << RET((i << 2) + 0));
Result |= ((((RET(y) >> i) & RET(1))) << RET((i << 2) + 1));
Result |= ((((RET(z) >> i) & RET(1))) << RET((i << 2) + 2));
Result |= ((((RET(w) >> i) & RET(1))) << RET((i << 2) + 3));
}
return Result;
}
*/
template <>
GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
{

2
deps/glm/gtx/closest_point.hpp vendored
View File

@ -53,7 +53,7 @@ namespace glm
/// Find the point on a straight line which is the closet of a point.
/// @see gtx_closest_point
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> closestPointOnLine(
detail::tvec3<T, P> closestPointOnLine(
detail::tvec3<T, P> const & point,
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b);

12
deps/glm/gtx/color_space.hpp vendored
View File

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

8
deps/glm/gtx/color_space_YCoCg.hpp vendored
View File

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

8
deps/glm/gtx/compatibility.hpp vendored
View File

@ -82,10 +82,10 @@ namespace glm
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename genType> bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)

8
deps/glm/gtx/component_wise.hpp vendored
View File

@ -53,25 +53,25 @@ namespace glm
/// Add all vector components together.
/// @see gtx_component_wise
template <typename genType>
GLM_FUNC_DECL typename genType::value_type compAdd(
typename genType::value_type compAdd(
genType const & v);
/// Multiply all vector components together.
/// @see gtx_component_wise
template <typename genType>
GLM_FUNC_DECL typename genType::value_type compMul(
typename genType::value_type compMul(
genType const & v);
/// Find the minimum value between single vector components.
/// @see gtx_component_wise
template <typename genType>
GLM_FUNC_DECL typename genType::value_type compMin(
typename genType::value_type compMin(
genType const & v);
/// Find the maximum value between single vector components.
/// @see gtx_component_wise
template <typename genType>
GLM_FUNC_DECL typename genType::value_type compMax(
typename genType::value_type compMax(
genType const & v);
/// @}

56
deps/glm/gtx/dual_quaternion.hpp vendored
View File

@ -63,74 +63,74 @@ namespace detail
public:
glm::detail::tquat<T, P> real, dual;
GLM_FUNC_DECL int length() const;
int length() const;
// Constructors
GLM_FUNC_DECL tdualquat();
GLM_FUNC_DECL explicit tdualquat(tquat<T, P> const & real);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & real,tquat<T, P> const & dual);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & orientation,tvec3<T, P> const& translation);
tdualquat();
explicit tdualquat(tquat<T, P> const & real);
tdualquat(tquat<T, P> const & real,tquat<T, P> const & dual);
tdualquat(tquat<T, P> const & orientation,tvec3<T, P> const& translation);
//////////////////////////////////////////////////////////////
// tdualquat conversions
GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);
explicit tdualquat(tmat2x4<T, P> const & holder_mat);
explicit tdualquat(tmat3x4<T, P> const & aug_mat);
// Accesses
GLM_FUNC_DECL part_type & operator[](int i);
GLM_FUNC_DECL part_type const & operator[](int i) const;
part_type & operator[](int i);
part_type const & operator[](int i) const;
// Operators
GLM_FUNC_DECL tdualquat<T, P> & operator*=(T const & s);
GLM_FUNC_DECL tdualquat<T, P> & operator/=(T const & s);
tdualquat<T, P> & operator*=(T const & s);
tdualquat<T, P> & operator/=(T const & s);
};
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator- (
detail::tquat<T, P> operator- (
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator+ (
detail::tdualquat<T, P> operator+ (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> operator* (
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> operator* (
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> operator* (
T const & s,
detail::tdualquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator/ (
detail::tdualquat<T, P> operator/ (
detail::tdualquat<T, P> const & q,
T const & s);
} //namespace detail
@ -142,14 +142,14 @@ namespace detail
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> normalize(
detail::tdualquat<T, P> normalize(
detail::tdualquat<T, P> const & q);
/// Returns the linear interpolation of two dual quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> lerp(
detail::tdualquat<T, P> lerp(
detail::tdualquat<T, P> const & x,
detail::tdualquat<T, P> const & y,
T const & a);
@ -158,7 +158,7 @@ namespace detail
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> inverse(
detail::tdualquat<T, P> inverse(
detail::tdualquat<T, P> const & q);
/*
@ -175,28 +175,28 @@ namespace detail
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x4<T, P> mat2x4_cast(
detail::tmat2x4<T, P> mat2x4_cast(
detail::tdualquat<T, P> const & x);
/// Converts a quaternion to a 3 * 4 matrix.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x4<T, P> mat3x4_cast(
detail::tmat3x4<T, P> mat3x4_cast(
detail::tdualquat<T, P> const & x);
/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tdualquat<T, P> dualquat_cast(
detail::tmat2x4<T, P> const & x);
/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tdualquat<T, P> dualquat_cast(
detail::tmat3x4<T, P> const & x);

30
deps/glm/gtx/euler_angles.hpp vendored
View File

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

2
deps/glm/gtx/extend.hpp vendored
View File

@ -53,7 +53,7 @@ namespace glm
/// Extends of Length the Origin position using the (Source - Origin) direction.
/// @see gtx_extend
template <typename genType>
GLM_FUNC_DECL genType extend(
genType extend(
genType const & Origin,
genType const & Source,
typename genType::value_type const Length);

24
deps/glm/gtx/extented_min_max.hpp vendored
View File

@ -54,7 +54,7 @@ namespace glm
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T>
GLM_FUNC_DECL T min(
T min(
T const & x,
T const & y,
T const & z);
@ -62,7 +62,7 @@ namespace glm
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> min(
C<T> const & x,
typename C<T>::T const & y,
typename C<T>::T const & z);
@ -70,7 +70,7 @@ namespace glm
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z);
@ -78,7 +78,7 @@ namespace glm
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T>
GLM_FUNC_DECL T min(
T min(
T const & x,
T const & y,
T const & z,
@ -87,7 +87,7 @@ namespace glm
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> min(
C<T> const & x,
typename C<T>::T const & y,
typename C<T>::T const & z,
@ -96,7 +96,7 @@ namespace glm
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z,
@ -105,7 +105,7 @@ namespace glm
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T>
GLM_FUNC_DECL T max(
T max(
T const & x,
T const & y,
T const & z);
@ -113,7 +113,7 @@ namespace glm
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> max(
C<T> const & x,
typename C<T>::T const & y,
typename C<T>::T const & z);
@ -121,7 +121,7 @@ namespace glm
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z);
@ -129,7 +129,7 @@ namespace glm
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T>
GLM_FUNC_DECL T max(
T max(
T const & x,
T const & y,
T const & z,
@ -138,7 +138,7 @@ namespace glm
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> max(
C<T> const & x,
typename C<T>::T const & y,
typename C<T>::T const & z,
@ -147,7 +147,7 @@ namespace glm
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template <typename T, template <typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z,

14
deps/glm/gtx/fast_exponential.hpp vendored
View File

@ -54,41 +54,41 @@ namespace glm
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename genType>
GLM_FUNC_DECL genType fastPow(
genType fastPow(
genType const & x,
genType const & y);
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT fastPow(
genTypeT fastPow(
genTypeT const & x,
genTypeU const & y);
/// Faster than the common exp function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastExp(const T& x);
T fastExp(const T& x);
/// Faster than the common log function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLog(const T& x);
T fastLog(const T& x);
/// Faster than the common exp2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastExp2(const T& x);
T fastExp2(const T& x);
/// Faster than the common log2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLog2(const T& x);
T fastLog2(const T& x);
/// Faster than the common ln function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLn(const T& x);
T fastLn(const T& x);
/// @}
}//namespace glm

12
deps/glm/gtx/fast_square_root.hpp vendored
View File

@ -55,32 +55,32 @@ namespace glm
//! Faster than the common sqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastSqrt(genType const & x);
genType fastSqrt(genType const & x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastInverseSqrt(genType const & x);
genType fastInverseSqrt(genType const & x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastInverseSqrt(vecType<T, P> const & x);
vecType<T, P> fastInverseSqrt(vecType<T, P> const & x);
//! Faster than the common length function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastLength(genType const & x);
typename genType::value_type fastLength(genType const & x);
//! Faster than the common distance function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastDistance(genType const & x, genType const & y);
typename genType::value_type fastDistance(genType const & x, genType const & y);
//! Faster than the common normalize function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastNormalize(genType const & x);
genType fastNormalize(genType const & x);
/// @}
}// namespace glm

14
deps/glm/gtx/fast_trigonometry.hpp vendored
View File

@ -54,43 +54,43 @@ namespace glm
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastSin(const T& angle);
T fastSin(const T& angle);
//! Faster than the common cos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastCos(const T& angle);
T fastCos(const T& angle);
//! Faster than the common tan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastTan(const T& angle);
T fastTan(const T& angle);
//! Faster than the common asin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAsin(const T& angle);
T fastAsin(const T& angle);
//! Faster than the common acos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAcos(const T& angle);
T fastAcos(const T& angle);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAtan(const T& y, const T& x);
T fastAtan(const T& y, const T& x);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAtan(const T& angle);
T fastAtan(const T& angle);
/// @}
}//namespace glm

4
deps/glm/gtx/gradient_paint.hpp vendored
View File

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

4
deps/glm/gtx/handed_coordinate_space.hpp vendored
View File

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

20
deps/glm/gtx/integer.hpp vendored
View File

@ -52,29 +52,29 @@ namespace glm
//! Returns x raised to the y power.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL int pow(int x, int y);
int pow(int x, int y);
//! Returns the positive square root of x.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL int sqrt(int x);
int sqrt(int x);
//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
//! From GLM_GTX_integer extension.
template <typename genIUType>
GLM_FUNC_DECL genIUType log2(genIUType x);
genIUType log2(genIUType x);
//! Returns the floor log2 of x.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);
unsigned int floor_log2(unsigned int x);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL int mod(int x, int y);
int mod(int x, int y);
//! Return the factorial value of a number (!12 max, integer only)
//! From GLM_GTX_integer extension.
template <typename genType>
GLM_FUNC_DECL genType factorial(genType const & x);
genType factorial(genType const & x);
//! 32bit signed integer.
//! From GLM_GTX_integer extension.
@ -82,19 +82,19 @@ namespace glm
//! Returns x raised to the y power.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL uint pow(uint x, uint y);
uint pow(uint x, uint y);
//! Returns the positive square root of x.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL uint sqrt(uint x);
uint sqrt(uint x);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL uint mod(uint x, uint y);
uint mod(uint x, uint y);
//! Returns the number of leading zeros.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL uint nlz(uint x);
uint nlz(uint x);
/// @}
}//namespace glm

12
deps/glm/gtx/intersect.hpp vendored
View File

@ -56,7 +56,7 @@ namespace glm
//! Ray direction and plane normal must be unit length.
//! From GLM_GTX_intersect extension.
template <typename genType>
GLM_FUNC_DECL bool intersectRayPlane(
bool intersectRayPlane(
genType const & orig, genType const & dir,
genType const & planeOrig, genType const & planeNormal,
typename genType::value_type & intersectionDistance);
@ -64,7 +64,7 @@ namespace glm
//! Compute the intersection of a ray and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
GLM_FUNC_DECL bool intersectRayTriangle(
bool intersectRayTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & baryPosition);
@ -72,7 +72,7 @@ namespace glm
//! Compute the intersection of a line and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
GLM_FUNC_DECL bool intersectLineTriangle(
bool intersectLineTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & position);
@ -81,7 +81,7 @@ namespace glm
//! The ray direction vector is unit length.
//! From GLM_GTX_intersect extension.
template <typename genType>
GLM_FUNC_DECL bool intersectRaySphere(
bool intersectRaySphere(
genType const & rayStarting, genType const & rayNormalizedDirection,
genType const & sphereCenter, typename genType::value_type const sphereRadiusSquered,
typename genType::value_type & intersectionDistance);
@ -89,7 +89,7 @@ namespace glm
//! Compute the intersection of a ray and a sphere.
//! From GLM_GTX_intersect extension.
template <typename genType>
GLM_FUNC_DECL bool intersectRaySphere(
bool intersectRaySphere(
genType const & rayStarting, genType const & rayNormalizedDirection,
genType const & sphereCenter, const typename genType::value_type sphereRadius,
genType & intersectionPosition, genType & intersectionNormal);
@ -97,7 +97,7 @@ namespace glm
//! Compute the intersection of a line and a sphere.
//! From GLM_GTX_intersect extension
template <typename genType>
GLM_FUNC_DECL bool intersectLineSphere(
bool intersectLineSphere(
genType const & point0, genType const & point1,
genType const & sphereCenter, typename genType::value_type sphereRadius,
genType & intersectionPosition1, genType & intersectionNormal1,

50
deps/glm/gtx/io.hpp vendored
View File

@ -62,8 +62,8 @@ namespace glm
public:
GLM_FUNC_DECL explicit precision_guard();
GLM_FUNC_DECL ~precision_guard();
explicit precision_guard();
~precision_guard();
private:
@ -77,8 +77,8 @@ namespace glm
public:
enum order_t { column_major, row_major, };
GLM_FUNC_DECL explicit format_guard();
GLM_FUNC_DECL ~format_guard();
explicit format_guard();
~format_guard();
private:
@ -87,59 +87,59 @@ namespace glm
};
// decimal places (dflt: 3)
GLM_FUNC_DECL unsigned& precision();
unsigned& precision();
// sign + value + '.' + decimals (dflt: 1 + 4 + 1 + precision())
GLM_FUNC_DECL unsigned& value_width();
unsigned& value_width();
// matrix output order (dflt: row_major)
GLM_FUNC_DECL format_guard::order_t& order();
format_guard::order_t& order();
// carriage/return char (dflt: '\n')
GLM_FUNC_DECL char& cr();
char& cr();
// matrix output order -> column_major
GLM_FUNC_DECL std::ios_base& column_major(std::ios_base&);
std::ios_base& column_major(std::ios_base&);
// matrix output order -> row_major
GLM_FUNC_DECL std::ios_base& row_major (std::ios_base&);
std::ios_base& row_major (std::ios_base&);
// carriage/return char -> '\n'
GLM_FUNC_DECL std::ios_base& formatted (std::ios_base&);
std::ios_base& formatted (std::ios_base&);
// carriage/return char -> ' '
GLM_FUNC_DECL std::ios_base& unformatted (std::ios_base&);
std::ios_base& unformatted (std::ios_base&);
}//namespace io
namespace detail
{
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
/// @}
}//namespace detail

2
deps/glm/gtx/log_base.hpp vendored
View File

@ -53,7 +53,7 @@ namespace glm
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename genType>
GLM_FUNC_DECL genType log(
genType log(
genType const & x,
genType const & base);

4
deps/glm/gtx/matrix_cross_product.hpp vendored
View File

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

8
deps/glm/gtx/matrix_interpolation.hpp vendored
View File

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

24
deps/glm/gtx/matrix_major_storage.hpp vendored
View File

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

18
deps/glm/gtx/matrix_operation.hpp vendored
View File

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

16
deps/glm/gtx/matrix_query.hpp vendored
View File

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

2
deps/glm/gtx/mixed_product.hpp vendored
View File

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

4
deps/glm/gtx/multiple.hpp vendored
View File

@ -59,7 +59,7 @@ namespace glm
///
/// @see gtx_multiple
template <typename genType>
GLM_FUNC_DECL genType higherMultiple(
genType higherMultiple(
genType const & Source,
genType const & Multiple);
@ -71,7 +71,7 @@ namespace glm
///
/// @see gtx_multiple
template <typename genType>
GLM_FUNC_DECL genType lowerMultiple(
genType lowerMultiple(
genType const & Source,
genType const & Multiple);

20
deps/glm/gtx/norm.hpp vendored
View File

@ -55,59 +55,59 @@ namespace glm
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
GLM_FUNC_DECL T length2(
T length2(
T const & x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type length2(
typename genType::value_type length2(
genType const & x);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
GLM_FUNC_DECL T distance2(
T distance2(
T const & p0,
T const & p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type distance2(
typename genType::value_type distance2(
genType const & p0,
genType const & p1);
//! Returns the L1 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
T l1Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
//! Returns the L1 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
T l1Norm(
detail::tvec3<T, P> const & v);
//! Returns the L2 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
T l2Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
//! Returns the L2 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
T l2Norm(
detail::tvec3<T, P> const & x);
//! Returns the L norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
T lxNorm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y,
unsigned int Depth);
@ -115,7 +115,7 @@ namespace glm
//! Returns the L norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
T lxNorm(
detail::tvec3<T, P> const & x,
unsigned int Depth);

2
deps/glm/gtx/normal.hpp vendored
View File

@ -54,7 +54,7 @@ namespace glm
//! Computes triangle normal from triangle points.
//! From GLM_GTX_normal extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> triangleNormal(
detail::tvec3<T, P> triangleNormal(
detail::tvec3<T, P> const & p1,
detail::tvec3<T, P> const & p2,
detail::tvec3<T, P> const & p3);

4
deps/glm/gtx/normalize_dot.hpp vendored
View File

@ -56,7 +56,7 @@ namespace glm
//! It's faster that dot(normalize(x), normalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type normalizeDot(
typename genType::value_type normalizeDot(
genType const & x,
genType const & y);
@ -64,7 +64,7 @@ namespace glm
//! Faster that dot(fastNormalize(x), fastNormalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastNormalizeDot(
typename genType::value_type fastNormalizeDot(
genType const & x,
genType const & y);

14
deps/glm/gtx/optimum_pow.hpp vendored
View File

@ -54,36 +54,36 @@ namespace gtx
//! Returns x raised to the power of 2.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
GLM_FUNC_DECL genType pow2(const genType& x);
genType pow2(const genType& x);
//! Returns x raised to the power of 3.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
GLM_FUNC_DECL genType pow3(const genType& x);
genType pow3(const genType& x);
//! Returns x raised to the power of 4.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
GLM_FUNC_DECL genType pow4(const genType& x);
genType pow4(const genType& x);
//! Checks if the parameter is a power of 2 number.
//! From GLM_GTX_optimum_pow extension.
GLM_FUNC_DECL bool powOfTwo(int num);
bool powOfTwo(int num);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec2<bool, P> powOfTwo(detail::tvec2<int, P> const & x);
detail::tvec2<bool, P> powOfTwo(detail::tvec2<int, P> const & x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec3<bool, P> powOfTwo(detail::tvec3<int, P> const & x);
detail::tvec3<bool, P> powOfTwo(detail::tvec3<int, P> const & x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> powOfTwo(detail::tvec4<int, P> const & x);
detail::tvec4<bool, P> powOfTwo(detail::tvec4<int, P> const & x);
/// @}
}//namespace gtx

4
deps/glm/gtx/orthonormalize.hpp vendored
View File

@ -54,13 +54,13 @@ namespace glm
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> orthonormalize(
detail::tmat3x3<T, P> orthonormalize(
const detail::tmat3x3<T, P>& m);
//! Orthonormalizes x according y.
//! From GLM_GTX_orthonormalize extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> orthonormalize(
detail::tvec3<T, P> orthonormalize(
const detail::tvec3<T, P>& x,
const detail::tvec3<T, P>& y);

2
deps/glm/gtx/perpendicular.hpp vendored
View File

@ -55,7 +55,7 @@ namespace glm
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename vecType>
GLM_FUNC_DECL vecType perp(
vecType perp(
vecType const & x,
vecType const & Normal);

4
deps/glm/gtx/polar_coordinates.hpp vendored
View File

@ -54,14 +54,14 @@ namespace glm
///
/// @see gtx_polar_coordinates
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> polar(
detail::tvec3<T, P> polar(
detail::tvec3<T, P> const & euclidean);
/// Convert Polar to Euclidean coordinates.
///
/// @see gtx_polar_coordinates
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> euclidean(
detail::tvec3<T, P> euclidean(
detail::tvec2<T, P> const & polar);
/// @}

2
deps/glm/gtx/projection.hpp vendored
View File

@ -53,7 +53,7 @@ namespace glm
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename vecType>
GLM_FUNC_DECL vecType proj(
vecType proj(
vecType const & x,
vecType const & Normal);

36
deps/glm/gtx/quaternion.hpp vendored
View File

@ -58,7 +58,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> cross(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
@ -66,7 +66,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> cross(
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
@ -75,7 +75,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> squad(
detail::tquat<T, P> squad(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2,
detail::tquat<T, P> const & s1,
@ -86,7 +86,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> intermediate(
detail::tquat<T, P> intermediate(
detail::tquat<T, P> const & prev,
detail::tquat<T, P> const & curr,
detail::tquat<T, P> const & next);
@ -95,21 +95,21 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> exp(
detail::tquat<T, P> exp(
detail::tquat<T, P> const & q);
//! Returns a log of a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> log(
detail::tquat<T, P> log(
detail::tquat<T, P> const & q);
/// Returns x raised to the y power.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> pow(
detail::tquat<T, P> pow(
detail::tquat<T, P> const & x,
T const & y);
@ -124,7 +124,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotate(
detail::tvec3<T, P> rotate(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
@ -132,7 +132,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotate(
detail::tvec4<T, P> rotate(
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
@ -140,42 +140,42 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL T extractRealComponent(
T extractRealComponent(
detail::tquat<T, P> const & q);
/// Converts a quaternion to a 3 * 3 matrix.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> toMat3(
detail::tmat3x3<T, P> toMat3(
detail::tquat<T, P> const & x){return mat3_cast(x);}
/// Converts a quaternion to a 4 * 4 matrix.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> toMat4(
detail::tmat4x4<T, P> toMat4(
detail::tquat<T, P> const & x){return mat4_cast(x);}
/// Converts a 3 * 3 matrix to a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> toQuat(
detail::tquat<T, P> toQuat(
detail::tmat3x3<T, P> const & x){return quat_cast(x);}
/// Converts a 4 * 4 matrix to a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> toQuat(
detail::tquat<T, P> toQuat(
detail::tmat4x4<T, P> const & x){return quat_cast(x);}
/// Quaternion interpolation using the rotation short path.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> shortMix(
detail::tquat<T, P> shortMix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
T const & a);
@ -184,7 +184,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> fastMix(
detail::tquat<T, P> fastMix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
T const & a);
@ -195,7 +195,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotation(
detail::tquat<T, P> rotation(
detail::tvec3<T, P> const & orig,
detail::tvec3<T, P> const & dest);
@ -203,7 +203,7 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL T length2(detail::tquat<T, P> const & q);
T length2(detail::tquat<T, P> const & q);
/// @}
}//namespace glm

4
deps/glm/gtx/rotate_normalized_axis.hpp vendored
View File

@ -66,7 +66,7 @@ namespace glm
/// @see - rotate(detail::tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, detail::tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rotateNormalizedAxis(
detail::tmat4x4<T, P> rotateNormalizedAxis(
detail::tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & axis);
@ -79,7 +79,7 @@ namespace glm
///
/// @see gtx_rotate_normalized_axis
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotateNormalizedAxis(
detail::tquat<T, P> rotateNormalizedAxis(
detail::tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & axis);

20
deps/glm/gtx/rotate_vector.hpp vendored
View File

@ -55,14 +55,14 @@ namespace glm
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec2<T, P> rotate(
detail::tvec2<T, P> rotate(
detail::tvec2<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotate(
detail::tvec3<T, P> rotate(
detail::tvec3<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal);
@ -70,7 +70,7 @@ namespace glm
//! Rotate a four dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotate(
detail::tvec4<T, P> rotate(
detail::tvec4<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal);
@ -78,49 +78,49 @@ namespace glm
//! Rotate a three dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateX(
detail::tvec3<T, P> rotateX(
detail::tvec3<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Y axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateY(
detail::tvec3<T, P> rotateY(
detail::tvec3<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Z axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateZ(
detail::tvec3<T, P> rotateZ(
detail::tvec3<T, P> const & v,
T const & angle);
//! Rotate a four dimentionnals vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateX(
detail::tvec4<T, P> rotateX(
detail::tvec4<T, P> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateY(
detail::tvec4<T, P> rotateY(
detail::tvec4<T, P> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateZ(
detail::tvec4<T, P> rotateZ(
detail::tvec4<T, P> const & v,
T const & angle);
//! Build a rotation matrix from a normal and a up vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> orientation(
detail::tmat4x4<T, P> orientation(
detail::tvec3<T, P> const & Normal,
detail::tvec3<T, P> const & Up);

2
deps/glm/gtx/simd_mat4.hpp vendored
View File

@ -69,7 +69,7 @@ namespace detail
typedef fmat4x4SIMD type;
typedef fmat4x4SIMD transpose_type;
GLM_FUNC_DECL length_t length() const;
length_t length() const;
fvec4SIMD Data[4];

6
deps/glm/gtx/spline.hpp vendored
View File

@ -54,7 +54,7 @@ namespace glm
//! Return a point from a catmull rom curve.
/// @see gtx_spline extension.
template <typename genType>
GLM_FUNC_DECL genType catmullRom(
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
@ -64,7 +64,7 @@ namespace glm
//! Return a point from a hermite curve.
/// @see gtx_spline extension.
template <typename genType>
GLM_FUNC_DECL genType hermite(
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
@ -74,7 +74,7 @@ namespace glm
//! Return a point from a cubic curve.
/// @see gtx_spline extension.
template <typename genType>
GLM_FUNC_DECL genType cubic(
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,

2
deps/glm/gtx/string_cast.hpp vendored
View File

@ -64,7 +64,7 @@ namespace glm
/// Create a string from a GLM type value.
/// @see gtx_string_cast extension.
template <typename genType>
GLM_FUNC_DECL std::string to_string(genType const & x);
std::string to_string(genType const & x);
/// @}
}//namespace glm

6
deps/glm/gtx/transform.hpp vendored
View File

@ -58,14 +58,14 @@ namespace glm
/// - From \link gtx_transform GLM_GTX_transform \endlink extension
/// - See also: \link glm::translate GLM_GTC_matrix_transform \endlink
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> translate(
detail::tmat4x4<T, P> translate(
detail::tvec3<T, P> const & v);
/// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
/// - From \link gtx_transform GLM_GTX_transform \endlink extension
/// - See also: \link glm::rotate GLM_GTC_matrix_transform \endlink
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rotate(
detail::tmat4x4<T, P> rotate(
T angle,
detail::tvec3<T, P> const & v);
@ -73,7 +73,7 @@ namespace glm
/// - From \link gtx_transform GLM_GTX_transform \endlink extension
/// - See also: \link glm::scale GLM_GTC_matrix_transform \endlink
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> scale(
detail::tmat4x4<T, P> scale(
detail::tvec3<T, P> const & v);
/// @}

26
deps/glm/gtx/transform2.hpp vendored
View File

@ -55,21 +55,21 @@ namespace glm
//! Transforms a matrix with a shearing on X axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> shearX2D(
detail::tmat3x3<T, P> shearX2D(
detail::tmat3x3<T, P> const & m,
T y);
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> shearY2D(
detail::tmat3x3<T, P> shearY2D(
detail::tmat3x3<T, P> const & m,
T x);
//! Transforms a matrix with a shearing on X axis
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> shearX3D(
detail::tmat4x4<T, P> shearX3D(
const detail::tmat4x4<T, P> & m,
T y,
T z);
@ -77,7 +77,7 @@ namespace glm
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> shearY3D(
detail::tmat4x4<T, P> shearY3D(
const detail::tmat4x4<T, P> & m,
T x,
T z);
@ -85,44 +85,36 @@ namespace glm
//! Transforms a matrix with a shearing on Z axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> shearZ3D(
detail::tmat4x4<T, P> shearZ3D(
const detail::tmat4x4<T, P> & m,
T x,
T y);
//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> shear(const detail::tmat4x4<T, P> & m, shearPlane, planePoint, angle)
// Identity + tan(angle) * cross(Normal, OnPlaneVector) 0
// - dot(PointOnPlane, normal) * OnPlaneVector 1
// Reflect functions seem to don't work
//template <typename T> detail::tmat3x3<T, P> reflect2D(const detail::tmat3x3<T, P> & m, const detail::tvec3<T, P>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
//template <typename T> detail::tmat4x4<T, P> reflect3D(const detail::tmat4x4<T, P> & m, const detail::tvec3<T, P>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> proj2D(
detail::tmat3x3<T, P> proj2D(
const detail::tmat3x3<T, P> & m,
const detail::tvec3<T, P>& normal);
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> proj3D(
detail::tmat4x4<T, P> proj3D(
const detail::tmat4x4<T, P> & m,
const detail::tvec3<T, P>& normal);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType, precision P>
GLM_FUNC_DECL detail::tmat4x4<valType, P> scaleBias(
detail::tmat4x4<valType, P> scaleBias(
valType scale,
valType bias);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType, precision P>
GLM_FUNC_DECL detail::tmat4x4<valType, P> scaleBias(
detail::tmat4x4<valType, P> scaleBias(
detail::tmat4x4<valType, P> const & m,
valType scale,
valType bias);

6
deps/glm/gtx/vector_angle.hpp vendored
View File

@ -59,7 +59,7 @@ namespace glm
//! Parameters need to be normalized.
/// @see gtx_vector_angle extension
template <typename vecType>
GLM_FUNC_DECL typename vecType::value_type angle(
typename vecType::value_type angle(
vecType const & x,
vecType const & y);
@ -67,7 +67,7 @@ namespace glm
//! Parameters need to be normalized.
/// @see gtx_vector_angle extension.
template <typename T, precision P>
GLM_FUNC_DECL T orientedAngle(
T orientedAngle(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> const & y);
@ -75,7 +75,7 @@ namespace glm
//! Parameters need to be normalized.
/// @see gtx_vector_angle extension.
template <typename T, precision P>
GLM_FUNC_DECL T orientedAngle(
T orientedAngle(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y,
detail::tvec3<T, P> const & ref);

12
deps/glm/gtx/vector_query.hpp vendored
View File

@ -55,32 +55,32 @@ namespace glm
//! Check whether two vectors are collinears.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL bool areCollinear(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
bool areCollinear(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
//! Check whether two vectors are orthogonals.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL bool areOrthogonal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
bool areOrthogonal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
//! Check whether a vector is normalized.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL bool isNormalized(vecType<T, P> const & v, T const & epsilon);
bool isNormalized(vecType<T, P> const & v, T const & epsilon);
//! Check whether a vector is null.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL bool isNull(vecType<T, P> const & v, T const & epsilon);
bool isNull(vecType<T, P> const & v, T const & epsilon);
//! Check whether a each component of a vector is null.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> isCompNull(vecType<T, P> const & v, T const & epsilon);
vecType<bool, P> isCompNull(vecType<T, P> const & v, T const & epsilon);
//! Check whether two vectors are orthonormal.
/// @see gtx_vector_query extensions.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL bool areOrthonormal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
bool areOrthonormal(vecType<T, P> const & v0, vecType<T, P> const & v1, T const & epsilon);
/// @}
}// namespace glm

6
deps/glm/gtx/wrap.hpp vendored
View File

@ -53,17 +53,17 @@ namespace glm
/// Simulate GL_CLAMP OpenGL wrap mode
/// @see gtx_wrap extension.
template <typename genType>
GLM_FUNC_DECL genType clamp(genType const & Texcoord);
genType clamp(genType const & Texcoord);
/// Simulate GL_REPEAT OpenGL wrap mode
/// @see gtx_wrap extension.
template <typename genType>
GLM_FUNC_DECL genType repeat(genType const & Texcoord);
genType repeat(genType const & Texcoord);
/// Simulate GL_MIRROR_REPEAT OpenGL wrap mode
/// @see gtx_wrap extension.
template <typename genType>
GLM_FUNC_DECL genType mirrorRepeat(genType const & Texcoord);
genType mirrorRepeat(genType const & Texcoord);
/// @}
}// namespace glm