AuroraMiddleware/glm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added possible static_cast conversion of GLM types (#72)

Browse Source
This commit is contained in:
Christophe Riccio 2013-12-27 00:49:53 +01:00
parent e5f8ebbfd7
commit d252dd243b
27 changed files with 30 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
glm/detail/type_mat2x2.hpp
View File

@ -92,15 +92,11 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat2x2(
U const & x);
template <typename U, typename V, typename M, typename N>
GLM_FUNC_DECL explicit tmat2x2(
U const & x1, V const & y1,
M const & x2, N const & y2);
template <typename U, typename V>
GLM_FUNC_DECL explicit tmat2x2(
tvec2<U, P> const & v1,

12
glm/detail/type_mat2x2.inl
View File

@ -154,18 +154,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T, P>(static_cast<T>(s), Zero);
this->value[1] = tvec2<T, P>(Zero, value_type(s));
}
template <typename T, precision P>
template <typename X1, typename Y1, typename X2, typename Y2>
GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2

4
glm/detail/type_mat2x3.hpp
View File

@ -82,10 +82,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat2x3(
U const & x);
template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
GLM_FUNC_DECL explicit tmat2x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,

16
glm/detail/type_mat2x3.inl
View File

@ -153,18 +153,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T, P>(static_cast<T>(s), Zero, Zero);
this->value[1] = tvec3<T, P>(Zero, value_type(s), Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1,
@ -173,7 +161,7 @@ namespace detail
(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2
)
)
{
this->value[0] = col_type(static_cast<T>(x1), value_type(y1), value_type(z1));
this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2));
@ -185,7 +173,7 @@ namespace detail
(
tvec3<V1, P> const & v1,
tvec3<V2, P> const & v2
)
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);

4
glm/detail/type_mat2x4.hpp
View File

@ -82,10 +82,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat2x4(
U const & x);
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2>

16
glm/detail/type_mat2x4.inl
View File

@ -156,18 +156,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec4<T, P>(static_cast<T>(s), Zero, Zero, Zero);
this->value[1] = tvec4<T, P>(Zero, value_type(s), Zero, Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1, typename W1,
@ -176,7 +164,7 @@ namespace detail
(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2
)
)
{
this->value[0] = col_type(static_cast<T>(x1), value_type(y1), value_type(z1), value_type(w1));
this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2), value_type(w2));
@ -188,7 +176,7 @@ namespace detail
(
tvec4<V1, P> const & v1,
tvec4<V2, P> const & v2
)
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);

4
glm/detail/type_mat3x2.hpp
View File

@ -84,10 +84,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x2(
U const & x);
template<
typename X1, typename Y1,
typename X2, typename Y2,

19
glm/detail/type_mat3x2.inl
View File

@ -163,19 +163,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T, P>(static_cast<T>(s), Zero);
this->value[1] = tvec2<T, P>(Zero, value_type(s));
this->value[2] = tvec2<T, P>(Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1,
@ -186,13 +173,13 @@ namespace detail
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3
)
)
{
this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
this->value[2] = col_type(static_cast<T>(x3), value_type(y3));
}
template <typename T, precision P>
template <typename V1, typename V2, typename V3>
GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
@ -200,7 +187,7 @@ namespace detail
tvec2<V1, P> const & v1,
tvec2<V2, P> const & v2,
tvec2<V3, P> const & v3
)
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);

4
glm/detail/type_mat3x3.hpp
View File

@ -93,10 +93,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x3(
U const & x);
template<
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,

13
glm/detail/type_mat3x3.inl
View File

@ -166,19 +166,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T, P>(static_cast<T>(s), Zero, Zero);
this->value[1] = tvec3<T, P>(Zero, value_type(s), Zero);
this->value[2] = tvec3<T, P>(Zero, Zero, value_type(s));
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1,

4
glm/detail/type_mat3x4.hpp
View File

@ -84,10 +84,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x4(
U const & x);
template<
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,

13
glm/detail/type_mat3x4.inl
View File

@ -139,19 +139,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec4<T, P>(static_cast<T>(s), Zero, Zero, Zero);
this->value[1] = tvec4<T, P>(Zero, value_type(s), Zero, Zero);
this->value[2] = tvec4<T, P>(Zero, Zero, value_type(s), Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1, typename W1,

9
glm/detail/type_mat4x2.hpp
View File

@ -86,10 +86,7 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x2(
U const & x);
template<
typename X1, typename Y1,
typename X2, typename Y2,
@ -100,7 +97,7 @@ namespace detail
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 explicit tmat4x2(
tvec2<V1, P> const & v1,
@ -111,7 +108,7 @@ namespace detail
// Matrix conversions
template <typename U, precision Q>
GLM_FUNC_DECL 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);

19
glm/detail/type_mat4x2.inl
View File

@ -144,20 +144,7 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T, P>(static_cast<T>(s), Zero);
this->value[1] = tvec2<T, P>(Zero, value_type(s));
this->value[2] = tvec2<T, P>(Zero, Zero);
this->value[3] = tvec2<T, P>(Zero, Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1,
@ -170,7 +157,7 @@ namespace detail
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3,
X4 const & x4, Y4 const & y4
)
)
{
this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
@ -186,7 +173,7 @@ namespace detail
tvec2<V2, P> const & v2,
tvec2<V3, P> const & v3,
tvec2<V4, P> const & v4
)
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);

3
glm/detail/type_mat4x3.hpp
View File

@ -86,9 +86,6 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x3(
U const & x);
template <
typename X1, typename Y1, typename Z1,

17
glm/detail/type_mat4x3.inl
View File

@ -169,20 +169,7 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T, P>(static_cast<T>(s), Zero, Zero);
this->value[1] = tvec3<T, P>(Zero, value_type(s), Zero);
this->value[2] = tvec3<T, P>(Zero, Zero, value_type(s));
this->value[3] = tvec3<T, P>(Zero, Zero, Zero);
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1,
@ -195,7 +182,7 @@ namespace detail
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
)
)
{
this->value[0] = col_type(static_cast<T>(x1), value_type(y1), value_type(z1));
this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2));

5
glm/detail/type_mat4x4.hpp
View File

@ -99,10 +99,7 @@ namespace detail
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x4(
U const & x);
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,

16
glm/detail/type_mat4x4.inl
View File

@ -191,22 +191,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
(
U const & s
)
{
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || std::numeric_limits<U>::is_integer, "*mat4x4 constructor only takes float and integer types");
value_type const Zero(0);
this->value[0] = tvec4<T, P>(static_cast<T>(s), Zero, Zero, Zero);
this->value[1] = tvec4<T, P>(Zero, value_type(s), Zero, Zero);
this->value[2] = tvec4<T, P>(Zero, Zero, value_type(s), Zero);
this->value[3] = tvec4<T, P>(Zero, Zero, Zero, value_type(s));
}
template <typename T, precision P>
template <
typename X1, typename Y1, typename Z1, typename W1,

4
glm/detail/type_vec2.hpp
View File

@ -137,10 +137,6 @@ namespace detail
//////////////////////////////////////
// Conversion constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(
U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V>
GLM_FUNC_DECL explicit tvec2(

10
glm/detail/type_vec2.inl
View File

@ -110,16 +110,6 @@ namespace detail
//////////////////////////////////////
// Conversion scalar constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
U const & x
) :
x(static_cast<T>(x)),
y(static_cast<T>(x))
{}
template <typename T, precision P>
template <typename U, typename V>

6
glm/detail/type_vec3.hpp
View File

@ -128,16 +128,12 @@ namespace detail
//////////////////////////////////////
// Conversion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec3(
U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V, typename W>
GLM_FUNC_DECL explicit tvec3(
U const & x,
V const & y,
W const & z);
W const & z);
//////////////////////////////////////
// Conversion vector constructors

11
glm/detail/type_vec3.inl
View File

@ -117,17 +117,6 @@ namespace detail
//////////////////////////////////////
// Conversion scalar constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
U const & s
) :
x(static_cast<T>(s)),
y(static_cast<T>(s)),
z(static_cast<T>(s))
{}
template <typename T, precision P>
template <typename A, typename B, typename C>

4
glm/detail/type_vec4.hpp
View File

@ -131,10 +131,6 @@ namespace detail
//////////////////////////////////////
// Conversion scalar constructors
/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec4(
U const & x);
/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, typename D>
GLM_FUNC_DECL explicit tvec4(

12
glm/detail/type_vec4.inl
View File

@ -125,18 +125,6 @@ namespace detail
//////////////////////////////////////
// Conversion scalar constructors
template <typename T, precision P>
template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
U const & x
) :
x(static_cast<T>(x)),
y(static_cast<T>(x)),
z(static_cast<T>(x)),
w(static_cast<T>(x))
{}
template <typename T, precision P>
template <typename A, typename B, typename C, typename D>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4

3
readme.txt
View File

@ -40,7 +40,8 @@ http://glm.g-truc.net/glm.pdf
GLM 0.9.5.1: 2014-XX-XX
--------------------------------------------------------------------------------
- Fixed angle and orientedAngle that sometimes return NaN values (#145)
- Deprecated degrees for function parameters and display a message.
- Deprecated degrees for function parameters and display a message
- Added possible static_cast conversion of GLM types (#72)
================================================================================
GLM 0.9.5.0: 2013-12-25

5
test/core/core_type_cast.cpp
View File

@ -27,8 +27,9 @@ int test_vec2_cast()
glm::mediump_vec2 G = static_cast<glm::mediump_vec2>(A);
glm::highp_vec2 H = static_cast<glm::highp_vec2>(A);
//my_vec2 I;
//glm::vec2 J = static_cast<glm::vec2>(I);
my_vec2 I;
glm::vec2 J = static_cast<glm::vec2>(I);
glm::vec2 K(7.8);
int Error(0);

8
test/gtc/gtc_matrix_transform.cpp
View File

@ -7,15 +7,21 @@
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/constants.hpp>
int main()
{
int Error = 0;
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Pick = glm::pickMatrix(glm::vec2(1, 2), glm::vec2(3, 4), glm::ivec4(0, 0, 320, 240));
glm::lowp_vec3 v(1.0);
glm::lowp_mat4 m(0);
glm::lowp_mat4 t = glm::translate(m, v);
return Error;
}