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

Fixed swizzle build on Visual C++ compiler

Browse Source
master
Christophe Riccio ago%!(EXTRA string=12 years)
parent 5a82afae6f
commit 281a391b4d
10 changed files with 560 additions and 776 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1002
      glm/core/_swizzle.hpp
  2. 12
      glm/core/type_float.hpp
  3. 2
      glm/core/type_mat2x2.inl
  4. 20
      glm/core/type_vec2.hpp
  5. 24
      glm/core/type_vec3.hpp
  6. 32
      glm/core/type_vec4.hpp
  7. 216
      glm/glm.cpp
  8. 8
      glm/glm.hpp
  9. 4
      glm/gtc/quaternion.hpp
  10. 16
      glm/gtc/quaternion.inl

1002
glm/core/_swizzle.hpp
View File

File diff suppressed because it is too large Load Diff

12
glm/core/type_float.hpp
Unescape View File

@ -87,20 +87,12 @@ namespace detail
# error "GLM error: multiple default precision requested for floating-point types" # error "GLM error: multiple default precision requested for floating-point types"
#endif #endif
typedef detail::half float16; typedef half float16;
typedef float float32; typedef float float32;
typedef double float64; typedef double float64;
/// @} /// @}
////////////////////
// check type sizes
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::float16) == 2, "float16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL
namespace detail namespace detail
{ {
////////////////// //////////////////
@ -129,7 +121,7 @@ namespace detail
//////////////////// ////////////////////
// Mark half to be flaot // Mark half to be flaot
GLM_DETAIL_IS_FLOAT(detail::half); GLM_DETAIL_IS_FLOAT(half);
GLM_DETAIL_IS_FLOAT(float); GLM_DETAIL_IS_FLOAT(float);
GLM_DETAIL_IS_FLOAT(double); GLM_DETAIL_IS_FLOAT(double);
GLM_DETAIL_IS_FLOAT(long double); GLM_DETAIL_IS_FLOAT(long double);

2
glm/core/type_mat2x2.inl
Unescape View File

@ -272,7 +272,7 @@ namespace detail
tmat2x2<T, P> Inverse( tmat2x2<T, P> Inverse(
+ this->value[1][1] / Determinant, + this->value[1][1] / Determinant,
- this->value[0][1] / Determinant, - this->value[0][1] / Determinant,
- this->value[1][0] / Determinant, - this->value[1][0] / Determinant,
+ this->value[0][0] / Determinant); + this->value[0][0] / Determinant);
return Inverse; return Inverse;
} }

20
glm/core/type_vec2.hpp
Unescape View File

@ -55,15 +55,15 @@ namespace detail
union union
{ {
# if(defined(GLM_SWIZZLE)) # if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE2_2_MEMBERS(T, glm::detail::tvec2<T, P>, x, y) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y)
_GLM_SWIZZLE2_2_MEMBERS(T, glm::detail::tvec2<T, P>, r, g) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g)
_GLM_SWIZZLE2_2_MEMBERS(T, glm::detail::tvec2<T, P>, s, t) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t)
_GLM_SWIZZLE2_3_MEMBERS(T, glm::detail::tvec3<T, P>, x, y) _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, x, y)
_GLM_SWIZZLE2_3_MEMBERS(T, glm::detail::tvec3<T, P>, r, g) _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, r, g)
_GLM_SWIZZLE2_3_MEMBERS(T, glm::detail::tvec3<T, P>, s, t) _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, s, t)
_GLM_SWIZZLE2_4_MEMBERS(T, glm::detail::tvec4<T, P>, x, y) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y)
_GLM_SWIZZLE2_4_MEMBERS(T, glm::detail::tvec4<T, P>, r, g) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g)
_GLM_SWIZZLE2_4_MEMBERS(T, glm::detail::tvec4<T, P>, s, t) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t)
# endif//(defined(GLM_SWIZZLE)) # endif//(defined(GLM_SWIZZLE))
struct {value_type r, g;}; struct {value_type r, g;};
@ -118,7 +118,7 @@ namespace detail
tvec2(tref2<T, P> const & r); tvec2(tref2<T, P> const & r);
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T, P>,E0,E1,-1,-2>& that) GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)
{ {
*this = that(); *this = that();
} }

24
glm/core/type_vec3.hpp
Unescape View File

@ -55,15 +55,15 @@ namespace detail
union union
{ {
# if(defined(GLM_SWIZZLE)) # if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z)
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b)
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z) _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, x, y, z)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b) _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, r, g, b)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p) _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, s, t, p)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p)
# endif//(defined(GLM_SWIZZLE)) # endif//(defined(GLM_SWIZZLE))
struct {value_type r, g, b;}; struct {value_type r, g, b;};
@ -156,19 +156,19 @@ namespace detail
GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B, P> const & v); GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B, P> const & v);
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T, P>, E0, E1, E2, -1> const & that) GLM_FUNC_DECL tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & that)
{ {
*this = that(); *this = that();
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & s) GLM_FUNC_DECL tvec3(_swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & s)
{ {
*this = tvec3<T, P>(v(), s); *this = tvec3<T, P>(v(), s);
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v) GLM_FUNC_DECL tvec3(T const & s, _swizzle<2, T, P, tvec2<T, P>, E0, E1, -1, -2> const & v)
{ {
*this = tvec3<T, P>(s, v()); *this = tvec3<T, P>(s, v());
} }

32
glm/core/type_vec4.hpp
Unescape View File

@ -55,15 +55,15 @@ namespace detail
union union
{ {
# if(defined(GLM_SWIZZLE)) # if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w)
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a)
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, s, t, p, q)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w) _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, x, y, z, w)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a) _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, r, g, b, a)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q) _GLM_SWIZZLE4_3_MEMBERS(T, P, tvec3, s, t, p, q)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, x, y, z, w)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q)
# endif//(defined(GLM_SWIZZLE)) # endif//(defined(GLM_SWIZZLE))
struct {value_type r, g, b, a;}; struct {value_type r, g, b, a;};
@ -157,43 +157,43 @@ namespace detail
GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
template <int E0, int E1, int E2, int E3> template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T, P>, E0, E1, E2, E3> const & that) GLM_FUNC_DECL tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const & that)
{ {
*this = that(); *this = that();
} }
template <int E0, int E1, int F0, int F1> template <int E0, int E1, int F0, int F1>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T, P>, F0, F1, -1, -2> const & u) 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)
{ {
*this = tvec4<T, P>(v(), u()); *this = tvec4<T, P>(v(), u());
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v) GLM_FUNC_DECL 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()); *this = tvec4<T, P>(x, y, v());
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & w) GLM_FUNC_DECL 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); *this = tvec4<T, P>(x, v(), w);
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T, P>, E0, E1, -1, -2> const & v, T const & z, T const & w) GLM_FUNC_DECL 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); *this = tvec4<T, P>(v(), z, w);
} }
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T, P>, E0, E1, E2, -1> const & v, T const & w) GLM_FUNC_DECL tvec4(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v, T const & w)
{ {
*this = tvec4<T, P>(v(), w); *this = tvec4<T, P>(v(), w);
} }
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T, P>, E0, E1, E2, -1> const & v) GLM_FUNC_DECL tvec4(T const & x, _swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & v)
{ {
*this = tvec4<T, P>(x, v()); *this = tvec4<T, P>(x, v());
} }

216
glm/glm.cpp
Unescape View File

@ -183,334 +183,118 @@ template struct tvec4<float32, highp>;
template struct tvec4<float64, highp>; template struct tvec4<float64, highp>;
// tmat2x2 type explicit instantiation // tmat2x2 type explicit instantiation
template struct tmat2x2<uint8, lowp>;
template struct tmat2x2<uint16, lowp>;
template struct tmat2x2<uint32, lowp>;
template struct tmat2x2<uint64, lowp>;
template struct tmat2x2<int8, lowp>;
template struct tmat2x2<int16, lowp>;
template struct tmat2x2<int32, lowp>;
template struct tmat2x2<int64, lowp>;
template struct tmat2x2<float16, lowp>; template struct tmat2x2<float16, lowp>;
template struct tmat2x2<float32, lowp>; template struct tmat2x2<float32, lowp>;
template struct tmat2x2<float64, lowp>; template struct tmat2x2<float64, lowp>;
template struct tmat2x2<uint8, mediump>;
template struct tmat2x2<uint16, mediump>;
template struct tmat2x2<uint32, mediump>;
template struct tmat2x2<uint64, mediump>;
template struct tmat2x2<int8, mediump>;
template struct tmat2x2<int16, mediump>;
template struct tmat2x2<int32, mediump>;
template struct tmat2x2<int64, mediump>;
template struct tmat2x2<float16, mediump>; template struct tmat2x2<float16, mediump>;
template struct tmat2x2<float32, mediump>; template struct tmat2x2<float32, mediump>;
template struct tmat2x2<float64, mediump>; template struct tmat2x2<float64, mediump>;
template struct tmat2x2<uint8, highp>;
template struct tmat2x2<uint16, highp>;
template struct tmat2x2<uint32, highp>;
template struct tmat2x2<uint64, highp>;
template struct tmat2x2<int8, highp>;
template struct tmat2x2<int16, highp>;
template struct tmat2x2<int32, highp>;
template struct tmat2x2<int64, highp>;
template struct tmat2x2<float16, highp>; template struct tmat2x2<float16, highp>;
template struct tmat2x2<float32, highp>; template struct tmat2x2<float32, highp>;
template struct tmat2x2<float64, highp>; template struct tmat2x2<float64, highp>;
// tmat2x3 type explicit instantiation // tmat2x3 type explicit instantiation
template struct tmat2x3<uint8, lowp>;
template struct tmat2x3<uint16, lowp>;
template struct tmat2x3<uint32, lowp>;
template struct tmat2x3<uint64, lowp>;
template struct tmat2x3<int8, lowp>;
template struct tmat2x3<int16, lowp>;
template struct tmat2x3<int32, lowp>;
template struct tmat2x3<int64, lowp>;
template struct tmat2x3<float16, lowp>; template struct tmat2x3<float16, lowp>;
template struct tmat2x3<float32, lowp>; template struct tmat2x3<float32, lowp>;
template struct tmat2x3<float64, lowp>; template struct tmat2x3<float64, lowp>;
template struct tmat2x3<uint8, mediump>;
template struct tmat2x3<uint16, mediump>;
template struct tmat2x3<uint32, mediump>;
template struct tmat2x3<uint64, mediump>;
template struct tmat2x3<int8, mediump>;
template struct tmat2x3<int16, mediump>;
template struct tmat2x3<int32, mediump>;
template struct tmat2x3<int64, mediump>;
template struct tmat2x3<float16, mediump>; template struct tmat2x3<float16, mediump>;
template struct tmat2x3<float32, mediump>; template struct tmat2x3<float32, mediump>;
template struct tmat2x3<float64, mediump>; template struct tmat2x3<float64, mediump>;
template struct tmat2x3<uint8, highp>;
template struct tmat2x3<uint16, highp>;
template struct tmat2x3<uint32, highp>;
template struct tmat2x3<uint64, highp>;
template struct tmat2x3<int8, highp>;
template struct tmat2x3<int16, highp>;
template struct tmat2x3<int32, highp>;
template struct tmat2x3<int64, highp>;
template struct tmat2x3<float16, highp>; template struct tmat2x3<float16, highp>;
template struct tmat2x3<float32, highp>; template struct tmat2x3<float32, highp>;
template struct tmat2x3<float64, highp>; template struct tmat2x3<float64, highp>;
// tmat2x4 type explicit instantiation // tmat2x4 type explicit instantiation
template struct tmat2x4<uint8, lowp>;
template struct tmat2x4<uint16, lowp>;
template struct tmat2x4<uint32, lowp>;
template struct tmat2x4<uint64, lowp>;
template struct tmat2x4<int8, lowp>;
template struct tmat2x4<int16, lowp>;
template struct tmat2x4<int32, lowp>;
template struct tmat2x4<int64, lowp>;
template struct tmat2x4<float16, lowp>; template struct tmat2x4<float16, lowp>;
template struct tmat2x4<float32, lowp>; template struct tmat2x4<float32, lowp>;
template struct tmat2x4<float64, lowp>; template struct tmat2x4<float64, lowp>;
template struct tmat2x4<uint8, mediump>;
template struct tmat2x4<uint16, mediump>;
template struct tmat2x4<uint32, mediump>;
template struct tmat2x4<uint64, mediump>;
template struct tmat2x4<int8, mediump>;
template struct tmat2x4<int16, mediump>;
template struct tmat2x4<int32, mediump>;
template struct tmat2x4<int64, mediump>;
template struct tmat2x4<float16, mediump>; template struct tmat2x4<float16, mediump>;
template struct tmat2x4<float32, mediump>; template struct tmat2x4<float32, mediump>;
template struct tmat2x4<float64, mediump>; template struct tmat2x4<float64, mediump>;
template struct tmat2x4<uint8, highp>;
template struct tmat2x4<uint16, highp>;
template struct tmat2x4<uint32, highp>;
template struct tmat2x4<uint64, highp>;
template struct tmat2x4<int8, highp>;
template struct tmat2x4<int16, highp>;
template struct tmat2x4<int32, highp>;
template struct tmat2x4<int64, highp>;
template struct tmat2x4<float16, highp>; template struct tmat2x4<float16, highp>;
template struct tmat2x4<float32, highp>; template struct tmat2x4<float32, highp>;
template struct tmat2x4<float64, highp>; template struct tmat2x4<float64, highp>;
// tmat3x2 type explicit instantiation // tmat3x2 type explicit instantiation
template struct tmat3x2<uint8, lowp>;
template struct tmat3x2<uint16, lowp>;
template struct tmat3x2<uint32, lowp>;
template struct tmat3x2<uint64, lowp>;
template struct tmat3x2<int8, lowp>;
template struct tmat3x2<int16, lowp>;
template struct tmat3x2<int32, lowp>;
template struct tmat3x2<int64, lowp>;
template struct tmat3x2<float16, lowp>; template struct tmat3x2<float16, lowp>;
template struct tmat3x2<float32, lowp>; template struct tmat3x2<float32, lowp>;
template struct tmat3x2<float64, lowp>; template struct tmat3x2<float64, lowp>;
template struct tmat3x2<uint8, mediump>;
template struct tmat3x2<uint16, mediump>;
template struct tmat3x2<uint32, mediump>;
template struct tmat3x2<uint64, mediump>;
template struct tmat3x2<int8, mediump>;
template struct tmat3x2<int16, mediump>;
template struct tmat3x2<int32, mediump>;
template struct tmat3x2<int64, mediump>;
template struct tmat3x2<float16, mediump>; template struct tmat3x2<float16, mediump>;
template struct tmat3x2<float32, mediump>; template struct tmat3x2<float32, mediump>;
template struct tmat3x2<float64, mediump>; template struct tmat3x2<float64, mediump>;
template struct tmat3x2<uint8, highp>;
template struct tmat3x2<uint16, highp>;
template struct tmat3x2<uint32, highp>;
template struct tmat3x2<uint64, highp>;
template struct tmat3x2<int8, highp>;
template struct tmat3x2<int16, highp>;
template struct tmat3x2<int32, highp>;
template struct tmat3x2<int64, highp>;
template struct tmat3x2<float16, highp>; template struct tmat3x2<float16, highp>;
template struct tmat3x2<float32, highp>; template struct tmat3x2<float32, highp>;
template struct tmat3x2<float64, highp>; template struct tmat3x2<float64, highp>;
// tmat3x3 type explicit instantiation // tmat3x3 type explicit instantiation
template struct tmat3x3<uint8, lowp>;
template struct tmat3x3<uint16, lowp>;
template struct tmat3x3<uint32, lowp>;
template struct tmat3x3<uint64, lowp>;
template struct tmat3x3<int8, lowp>;
template struct tmat3x3<int16, lowp>;
template struct tmat3x3<int32, lowp>;
template struct tmat3x3<int64, lowp>;
template struct tmat3x3<float16, lowp>; template struct tmat3x3<float16, lowp>;
template struct tmat3x3<float32, lowp>; template struct tmat3x3<float32, lowp>;
template struct tmat3x3<float64, lowp>; template struct tmat3x3<float64, lowp>;
template struct tmat3x3<uint8, mediump>;
template struct tmat3x3<uint16, mediump>;
template struct tmat3x3<uint32, mediump>;
template struct tmat3x3<uint64, mediump>;
template struct tmat3x3<int8, mediump>;
template struct tmat3x3<int16, mediump>;
template struct tmat3x3<int32, mediump>;
template struct tmat3x3<int64, mediump>;
template struct tmat3x3<float16, mediump>; template struct tmat3x3<float16, mediump>;
template struct tmat3x3<float32, mediump>; template struct tmat3x3<float32, mediump>;
template struct tmat3x3<float64, mediump>; template struct tmat3x3<float64, mediump>;
template struct tmat3x3<uint8, highp>;
template struct tmat3x3<uint16, highp>;
template struct tmat3x3<uint32, highp>;
template struct tmat3x3<uint64, highp>;
template struct tmat3x3<int8, highp>;
template struct tmat3x3<int16, highp>;
template struct tmat3x3<int32, highp>;
template struct tmat3x3<int64, highp>;
template struct tmat3x3<float16, highp>; template struct tmat3x3<float16, highp>;
template struct tmat3x3<float32, highp>; template struct tmat3x3<float32, highp>;
template struct tmat3x3<float64, highp>; template struct tmat3x3<float64, highp>;
// tmat3x4 type explicit instantiation // tmat3x4 type explicit instantiation
template struct tmat3x4<uint8, lowp>;
template struct tmat3x4<uint16, lowp>;
template struct tmat3x4<uint32, lowp>;
template struct tmat3x4<uint64, lowp>;
template struct tmat3x4<int8, lowp>;
template struct tmat3x4<int16, lowp>;
template struct tmat3x4<int32, lowp>;
template struct tmat3x4<int64, lowp>;
template struct tmat3x4<float16, lowp>; template struct tmat3x4<float16, lowp>;
template struct tmat3x4<float32, lowp>; template struct tmat3x4<float32, lowp>;
template struct tmat3x4<float64, lowp>; template struct tmat3x4<float64, lowp>;
template struct tmat3x4<uint8, mediump>;
template struct tmat3x4<uint16, mediump>;
template struct tmat3x4<uint32, mediump>;
template struct tmat3x4<uint64, mediump>;
template struct tmat3x4<int8, mediump>;
template struct tmat3x4<int16, mediump>;
template struct tmat3x4<int32, mediump>;
template struct tmat3x4<int64, mediump>;
template struct tmat3x4<float16, mediump>; template struct tmat3x4<float16, mediump>;
template struct tmat3x4<float32, mediump>; template struct tmat3x4<float32, mediump>;
template struct tmat3x4<float64, mediump>; template struct tmat3x4<float64, mediump>;
template struct tmat3x4<uint8, highp>;
template struct tmat3x4<uint16, highp>;
template struct tmat3x4<uint32, highp>;
template struct tmat3x4<uint64, highp>;
template struct tmat3x4<int8, highp>;
template struct tmat3x4<int16, highp>;
template struct tmat3x4<int32, highp>;
template struct tmat3x4<int64, highp>;
template struct tmat3x4<float16, highp>; template struct tmat3x4<float16, highp>;
template struct tmat3x4<float32, highp>; template struct tmat3x4<float32, highp>;
template struct tmat3x4<float64, highp>; template struct tmat3x4<float64, highp>;
// tmat4x2 type explicit instantiation // tmat4x2 type explicit instantiation
template struct tmat4x2<uint8, lowp>;
template struct tmat4x2<uint16, lowp>;
template struct tmat4x2<uint32, lowp>;
template struct tmat4x2<uint64, lowp>;
template struct tmat4x2<int8, lowp>;
template struct tmat4x2<int16, lowp>;
template struct tmat4x2<int32, lowp>;
template struct tmat4x2<int64, lowp>;
template struct tmat4x2<float16, lowp>; template struct tmat4x2<float16, lowp>;
template struct tmat4x2<float32, lowp>; template struct tmat4x2<float32, lowp>;
template struct tmat4x2<float64, lowp>; template struct tmat4x2<float64, lowp>;
template struct tmat4x2<uint8, mediump>;
template struct tmat4x2<uint16, mediump>;
template struct tmat4x2<uint32, mediump>;
template struct tmat4x2<uint64, mediump>;
template struct tmat4x2<int8, mediump>;
template struct tmat4x2<int16, mediump>;
template struct tmat4x2<int32, mediump>;
template struct tmat4x2<int64, mediump>;
template struct tmat4x2<float16, mediump>; template struct tmat4x2<float16, mediump>;
template struct tmat4x2<float32, mediump>; template struct tmat4x2<float32, mediump>;
template struct tmat4x2<float64, mediump>; template struct tmat4x2<float64, mediump>;
template struct tmat4x2<uint8, highp>;
template struct tmat4x2<uint16, highp>;
template struct tmat4x2<uint32, highp>;
template struct tmat4x2<uint64, highp>;
template struct tmat4x2<int8, highp>;
template struct tmat4x2<int16, highp>;
template struct tmat4x2<int32, highp>;
template struct tmat4x2<int64, highp>;
template struct tmat4x2<float16, highp>; template struct tmat4x2<float16, highp>;
template struct tmat4x2<float32, highp>; template struct tmat4x2<float32, highp>;
template struct tmat4x2<float64, highp>; template struct tmat4x2<float64, highp>;
// tmat4x3 type explicit instantiation // tmat4x3 type explicit instantiation
template struct tmat4x3<uint8, lowp>;
template struct tmat4x3<uint16, lowp>;
template struct tmat4x3<uint32, lowp>;
template struct tmat4x3<uint64, lowp>;
template struct tmat4x3<int8, lowp>;
template struct tmat4x3<int16, lowp>;
template struct tmat4x3<int32, lowp>;
template struct tmat4x3<int64, lowp>;
template struct tmat4x3<float16, lowp>; template struct tmat4x3<float16, lowp>;
template struct tmat4x3<float32, lowp>; template struct tmat4x3<float32, lowp>;
template struct tmat4x3<float64, lowp>; template struct tmat4x3<float64, lowp>;
template struct tmat4x3<uint8, mediump>;
template struct tmat4x3<uint16, mediump>;
template struct tmat4x3<uint32, mediump>;
template struct tmat4x3<uint64, mediump>;
template struct tmat4x3<int8, mediump>;
template struct tmat4x3<int16, mediump>;
template struct tmat4x3<int32, mediump>;
template struct tmat4x3<int64, mediump>;
template struct tmat4x3<float16, mediump>; template struct tmat4x3<float16, mediump>;
template struct tmat4x3<float32, mediump>; template struct tmat4x3<float32, mediump>;
template struct tmat4x3<float64, mediump>; template struct tmat4x3<float64, mediump>;
template struct tmat4x3<uint8, highp>;
template struct tmat4x3<uint16, highp>;
template struct tmat4x3<uint32, highp>;
template struct tmat4x3<uint64, highp>;
template struct tmat4x3<int8, highp>;
template struct tmat4x3<int16, highp>;
template struct tmat4x3<int32, highp>;
template struct tmat4x3<int64, highp>;
template struct tmat4x3<float16, highp>; template struct tmat4x3<float16, highp>;
template struct tmat4x3<float32, highp>; template struct tmat4x3<float32, highp>;
template struct tmat4x3<float64, highp>; template struct tmat4x3<float64, highp>;
// tmat4x4 type explicit instantiation // tmat4x4 type explicit instantiation
template struct tmat4x4<uint8, lowp>;
template struct tmat4x4<uint16, lowp>;
template struct tmat4x4<uint32, lowp>;
template struct tmat4x4<uint64, lowp>;
template struct tmat4x4<int8, lowp>;
template struct tmat4x4<int16, lowp>;
template struct tmat4x4<int32, lowp>;
template struct tmat4x4<int64, lowp>;
template struct tmat4x4<float16, lowp>; template struct tmat4x4<float16, lowp>;
template struct tmat4x4<float32, lowp>; template struct tmat4x4<float32, lowp>;
template struct tmat4x4<float64, lowp>; template struct tmat4x4<float64, lowp>;
template struct tmat4x4<uint8, mediump>;
template struct tmat4x4<uint16, mediump>;
template struct tmat4x4<uint32, mediump>;
template struct tmat4x4<uint64, mediump>;
template struct tmat4x4<int8, mediump>;
template struct tmat4x4<int16, mediump>;
template struct tmat4x4<int32, mediump>;
template struct tmat4x4<int64, mediump>;
template struct tmat4x4<float16, mediump>; template struct tmat4x4<float16, mediump>;
template struct tmat4x4<float32, mediump>; template struct tmat4x4<float32, mediump>;
template struct tmat4x4<float64, mediump>; template struct tmat4x4<float64, mediump>;
template struct tmat4x4<uint8, highp>;
template struct tmat4x4<uint16, highp>;
template struct tmat4x4<uint32, highp>;
template struct tmat4x4<uint64, highp>;
template struct tmat4x4<int8, highp>;
template struct tmat4x4<int16, highp>;
template struct tmat4x4<int32, highp>;
template struct tmat4x4<int64, highp>;
template struct tmat4x4<float16, highp>; template struct tmat4x4<float16, highp>;
template struct tmat4x4<float32, highp>; template struct tmat4x4<float32, highp>;
template struct tmat4x4<float64, highp>; template struct tmat4x4<float64, highp>;

8
glm/glm.hpp
Unescape View File

@ -129,4 +129,12 @@
#include "./core/_swizzle.hpp" #include "./core/_swizzle.hpp"
////////////////////
// check type sizes
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::float16) == 2, "float16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL
#endif//glm_glm #endif//glm_glm

4
glm/gtc/quaternion.hpp
Unescape View File

@ -91,8 +91,8 @@ namespace detail
tmat4x4<T, P> const & m); tmat4x4<T, P> const & m);
// Accesses // Accesses
GLM_FUNC_DECL value_type & operator[](int i); GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](int i) const; GLM_FUNC_DECL value_type const & operator[](size_type i) const;
// Operators // Operators
GLM_FUNC_DECL tquat<T, P> & operator*=(value_type const & s); GLM_FUNC_DECL tquat<T, P> & operator*=(value_type const & s);

16
glm/gtc/quaternion.inl
Unescape View File

@ -141,13 +141,13 @@ namespace detail
// tquat<T, P> accesses // tquat<T, P> accesses
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T & tquat<T, P>::operator [](int i) GLM_FUNC_QUALIFIER T & tquat<T, P>::operator[] (size_type i)
{ {
return (&x)[i]; return (&x)[i];
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T const & tquat<T, P>::operator [](int i) const GLM_FUNC_QUALIFIER T const & tquat<T, P>::operator[] (size_type i) const
{ {
return (&x)[i]; return (&x)[i];
} }
@ -796,7 +796,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] < y[i]; Result[i] = x[i] < y[i];
@ -810,7 +810,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] <= y[i]; Result[i] = x[i] <= y[i];
return Result; return Result;
@ -823,7 +823,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] > y[i]; Result[i] = x[i] > y[i];
return Result; return Result;
@ -836,7 +836,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] >= y[i]; Result[i] = x[i] >= y[i];
return Result; return Result;
@ -849,7 +849,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] == y[i]; Result[i] = x[i] == y[i];
return Result; return Result;
@ -862,7 +862,7 @@ namespace detail
detail::tquat<T, P> const & y detail::tquat<T, P> const & y
) )
{ {
typename detail::tquat<T, P>::bool_type Result(detail::tquat<T, P>::null); typename detail::tquat<T, P>::bool_type Result;
for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i) for(typename detail::tquat<T, P>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] != y[i]; Result[i] = x[i] != y[i];
return Result; return Result;

Write Preview
Loading…
Cancel
Save