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

Merge branch '0.9.1' of ssh://ogl-math.git.sourceforge.net/gitroot/ogl-math/ogl-math into 0.9.1

Browse Source
This commit is contained in:
Christophe Riccio 2011-03-18 01:35:45 +00:00
commit 04fdc2cc0e
19 changed files with 202 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
glm/core/func_integer.inl
View File

@ -274,7 +274,7 @@ namespace glm
Result |= (1 << (sizeof(genIUType) * 8 - 1)) & (1 << (Offset + Bits - 1));
genIUType Mask = 0;
for(std::size_t Bit = Offset; Bit < Bits; ++Bit)
for(int Bit = Offset; Bit < Bits; ++Bit)
Mask |= (1 << Bit);
return Result | ((Mask & Value) >> Offset);
@ -339,7 +339,7 @@ namespace glm
return Base;
genIUType Mask = 0;
for(std::size_t Bit = Offset; Bit < Offset + Bits; ++Bit)
for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
Mask |= (1 << Bit);
return (Base & ~Mask) | (Insert & Mask);

17
glm/core/setup.hpp
View File

@ -401,21 +401,4 @@
# endif
#endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Precision
#define GLM_PRECISION_NONE 0x00000000
#define GLM_PRECISION_LOWP_FLOAT 0x00000011
#define GLM_PRECISION_MEDIUMP_FLOAT 0x00000012
#define GLM_PRECISION_HIGHP_FLOAT 0x00000013
#define GLM_PRECISION_LOWP_INT 0x00001100
#define GLM_PRECISION_MEDIUMP_INT 0x00001200
#define GLM_PRECISION_HIGHP_INT 0x00001300
#define GLM_PRECISION_LOWP_UINT 0x00110000
#define GLM_PRECISION_MEDIUMP_UINT 0x00120000
#define GLM_PRECISION_HIGHP_UINT 0x00130000
#endif//glm_setup

18
glm/core/type.hpp
View File

@ -38,7 +38,7 @@ namespace type
//////////////////////////
// Float definition
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef precision::highp_vec2 vec2;
typedef precision::highp_vec3 vec3;
typedef precision::highp_vec4 vec4;
@ -51,7 +51,7 @@ namespace type
typedef precision::highp_mat4x2 mat4x2;
typedef precision::highp_mat4x3 mat4x3;
typedef precision::highp_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef precision::mediump_vec2 vec2;
typedef precision::mediump_vec3 vec3;
typedef precision::mediump_vec4 vec4;
@ -64,7 +64,7 @@ namespace type
typedef precision::mediump_mat4x2 mat4x2;
typedef precision::mediump_mat4x3 mat4x3;
typedef precision::mediump_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_vec2 vec2;
typedef precision::lowp_vec3 vec3;
typedef precision::lowp_vec4 vec4;
@ -158,15 +158,15 @@ namespace type
//////////////////////////
// Signed integer definition
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef precision::highp_ivec2 ivec2;
typedef precision::highp_ivec3 ivec3;
typedef precision::highp_ivec4 ivec4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef precision::mediump_ivec2 ivec2;
typedef precision::mediump_ivec3 ivec3;
typedef precision::mediump_ivec4 ivec4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_INT)
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_ivec2 ivec2;
typedef precision::lowp_ivec3 ivec3;
typedef precision::lowp_ivec4 ivec4;
@ -190,15 +190,15 @@ namespace type
//////////////////////////
// Unsigned integer definition
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef precision::highp_uvec2 uvec2;
typedef precision::highp_uvec3 uvec3;
typedef precision::highp_uvec4 uvec4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef precision::mediump_uvec2 uvec2;
typedef precision::mediump_uvec3 uvec3;
typedef precision::mediump_uvec4 uvec4;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uvec2 uvec2;
typedef precision::lowp_uvec3 uvec3;
typedef precision::lowp_uvec4 uvec4;

13
glm/core/type_float.hpp
View File

@ -55,18 +55,17 @@ namespace glm
}
//namespace precision
#ifndef GLM_PRECISION
#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::mediump_float float_t;
#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::highp_float float_t;
#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::mediump_float float_t;
#elif(GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_float float_t;
#else
# pragma message("GLM message: Precisson undefined for float numbers.");
typedef precision::mediump_float float_t;
#endif//GLM_PRECISION
# error "GLM error: multiple default precision requested for floating-point types"
#endif
}//namespace type
}//namespace core

26
glm/core/type_int.hpp
View File

@ -79,31 +79,29 @@ namespace glm
}
//namespace precision
#ifndef GLM_PRECISION
#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef precision::mediump_int int_t;
#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef precision::highp_int int_t;
#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef precision::mediump_int int_t;
#elif(GLM_PRECISION & GLM_PRECISION_LOWP_INT)
#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_int int_t;
#else
typedef precision::mediump_int int_t;
# pragma message("GLM message: Precisson undefined for signed integer number.");
#endif//GLM_PRECISION
# error "GLM error: multiple default precision requested for signed interger types"
#endif
#ifndef GLM_PRECISION
#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef precision::mediump_uint uint_t;
#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef precision::highp_uint uint_t;
#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef precision::mediump_uint uint_t;
#elif(GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uint uint_t;
#else
typedef precision::mediump_uint uint_t;
# pragma message("GLM message: Precisson undefined for unsigned integer number.");
#endif//GLM_PRECISION
# error "GLM error: multiple default precision requested for unsigned interger types"
#endif
//! Unsigned integer.
//! From GLSL 1.30.8 specification section 4.1.3 Integers.

17
glm/gtc/matrix_integer.hpp
View File

@ -117,11 +117,10 @@ namespace glm
typedef detail::tmat4x3<lowp_uint> lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_uint> lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_HIGHP_INT))
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -131,8 +130,7 @@ namespace glm
typedef highp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#elif(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_LOWP_INT))
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -145,8 +143,7 @@ namespace glm
typedef lowp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#else //if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT))
#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
typedef mediump_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -161,7 +158,7 @@ namespace glm
typedef mediump_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_HIGHP_UINT))
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef highp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -174,8 +171,7 @@ namespace glm
typedef highp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#elif(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_LOWP_UINT))
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -188,8 +184,7 @@ namespace glm
typedef lowp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#else //if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT))
#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef mediump_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)

2
glm/gtc/matrix_transform.inl
View File

@ -359,7 +359,7 @@ namespace matrix_transform
// Translate and scale the picked region to the entire window
Result = translate(Result, Temp);
return scale(Result, T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1));
return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
}
template <typename T>

18
glm/gtx/vec1.hpp
View File

@ -80,11 +80,11 @@ namespace glm
//! From GLM_GTX_vec1 extension.
typedef detail::tvec1<bool> bvec1;
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef precision::highp_vec1 vec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef precision::mediump_vec1 vec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_vec1 vec1;
#else
//! 1 component vector of floating-point numbers.
@ -92,11 +92,11 @@ namespace glm
typedef precision::mediump_vec1 vec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef precision::highp_ivec1 ivec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef precision::mediump_ivec1 ivec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_INT)
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_ivec1 ivec1;
#else
//! 1 component vector of signed integer numbers.
@ -104,11 +104,11 @@ namespace glm
typedef precision::mediump_ivec1 ivec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef precision::highp_uvec1 uvec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef precision::mediump_uvec1 uvec1;
#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uvec1 uvec1;
#else
//! 1 component vector of unsigned integer numbers.

1
test/core/core_type_mat4x4.cpp
View File

@ -8,6 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#define GLM_PRECISION_HIGHP_FLOAT
#include <glm/glm.hpp>
#include <cstdio>

11
test/gtc/CMakeLists.txt
View File

@ -1,2 +1,9 @@
glmCreateTestGTC(gtc-integer-matrix)
glmCreateTestGTC(gtc-swizzle)
glmCreateTestGTC(gtc_half_float)
glmCreateTestGTC(gtc_matrix_access)
glmCreateTestGTC(gtc_matrix_integer)
glmCreateTestGTC(gtc_matrix_inverse)
glmCreateTestGTC(gtc_matrix_transform)
glmCreateTestGTC(gtc_quaternion)
glmCreateTestGTC(gtc_swizzle)
glmCreateTestGTC(gtc_type_precision)
glmCreateTestGTC(gtc_type_ptr)

19
test/gtc/gtc_half_float.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}

19
test/gtc/gtc_matrix_access.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}

12
test/gtc/gtc-integer-matrix.cpp → test/gtc/gtc_matrix_integer.cpp
View File

@ -4,26 +4,16 @@
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtx/simd-mat4.cpp
// File : test/gtc/matrix_integer.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_integer.hpp>
int test_int_matrix()
{
{
glm::mediump_uint A(0);
}
return 0;
}
int main()
{
int Failed = 0;
Failed += test_int_matrix();
return Failed;
}

19
test/gtc/gtc_matrix_inverse.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}

21
test/gtc/gtc_matrix_transform.cpp Normal file
View File

@ -0,0 +1,21 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
glm::mat4 Pick = glm::pickMatrix(glm::vec2(1, 2), glm::vec2(3, 4), glm::ivec4(0, 0, 320, 240));
return Failed;
}

19
test/gtc/gtc_quaternion.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}

2
test/gtc/gtc-swizzle.cpp → test/gtc/gtc_swizzle.cpp
View File

@ -4,7 +4,7 @@
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtx/simd-mat4.cpp
// File : test/gtc/swizzle.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES

19
test/gtc/gtc_type_precision.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}

19
test/gtc/gtc_type_ptr.cpp Normal file
View File

@ -0,0 +1,19 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2010-09-16
// Updated : 2010-09-16
// Licence : This source is under MIT licence
// File : test/gtc/matrix_transform.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int main()
{
int Failed = 0;
return Failed;
}