mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-09-20 16:32:16 +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-02-22 01:37:07 +00:00
commit b3ab977291
18 changed files with 254 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
CMakeLists.txt
View File

@ -2,11 +2,13 @@ cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
cmake_policy(VERSION 2.6)
project(glm)
enable_testing()
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
add_definitions(-pedantic)
#add_definitions(-S)
#add_definitions(-s)
#add_definitions(-msse2)
add_definitions(-msse2)
#add_definitions(-m32)
#add_definitions(-mfpmath=387)
#add_definitions(-ffast-math)
@ -14,12 +16,15 @@ add_definitions(-D_CRT_SECURE_NO_WARNINGS)
include_directories(".")
add_subdirectory(glm)
add_subdirectory(test)
add_subdirectory(bench)
add_subdirectory(doc)
option(GLM_DEVELOPMENT_MODE "GLM development" OFF)
if(NOT GLM_DEVELOPMENT_MODE)
message(FATAL_ERROR "GLM is a header only library, no need to build it")
option(GLM_TEST_MODE "GLM test" OFF)
if(NOT GLM_TEST_MODE)
message(FATAL_ERROR "GLM is a header only library, no need to build it. Set the option GLM_TEST_MODE with ON to build and run the test bench")
endif()
install( DIRECTORY glm DESTINATION include )

2
doc/theme/doxygen.css vendored
View File

@ -126,6 +126,8 @@ a {
margin-left:auto;
margin-right:auto;
padding:0px;
padding-top:8px;
padding-bottom:8px;
width:1000px;
}

21
glm/core/_detail.hpp
View File

@ -10,7 +10,7 @@
#ifndef glm_core_detail
#define glm_core_detail
#include "../setup.hpp"
#include "setup.hpp"
#include <cassert>
namespace glm{
@ -24,6 +24,16 @@ namespace detail
#elif(GLM_COMPILER & GLM_COMPILER_GCC)
__extension__ typedef signed long long sint64;
__extension__ typedef unsigned long long uint64;
//# if GLM_MODEL == GLM_MODEL_64
// typedef signed long highp_int_t;
// typedef unsigned long highp_uint_t;
//# elif GLM_MODEL == GLM_MODEL_32
// __extension__ typedef signed long long highp_int_t;
// __extension__ typedef unsigned long long highp_uint_t;
//# endif//GLM_MODEL
#elif(GLM_COMPILER & GLM_COMPILER_BC)
typedef Int64 sint64;
typedef Uint64 uint64;
#else//unknown compiler
typedef signed long sint64;
typedef unsigned long uint64;
@ -259,7 +269,7 @@ namespace detail
_YES = 1, \
_NO = 0 \
}; \
};
}
//////////////////
// matrix
@ -323,11 +333,13 @@ namespace detail
#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
# define GLM_DEPRECATED __declspec(deprecated)
# define GLM_ALIGN(x) __declspec(align(x))
# define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
# define GLM_RESTRICT __declspec(restrict)
# define GLM_RESTRICT_VAR __restrict
#elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC31))
# define GLM_DEPRECATED __attribute__((__deprecated__))
# define GLM_ALIGN(x) __attribute__((aligned(x)))
# define GLM_ALIGN(x) __attribute__((aligned(x)))
# define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
# if(GLM_COMPILER >= GLM_COMPILER_GCC33)
# define GLM_RESTRICT __restrict__
# define GLM_RESTRICT_VAR __restrict__
@ -339,7 +351,8 @@ namespace detail
# define GLM_RESTRICT_VAR __restrict__
#else
# define GLM_DEPRECATED
# define GLM_ALIGN(x)
# define GLM_ALIGN
# define GLM_ALIGNED_STRUCT(x)
# define GLM_RESTRICT
# define GLM_RESTRICT_VAR
#endif//GLM_COMPILER

18
glm/core/_fixes.hpp Normal file
View File

@ -0,0 +1,18 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2011-02-21
// Updated : 2011-02-21
// Licence : This source is under MIT License
// File : glm/core/_fixes.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////
//! Workaround for compatibility with other libraries
#ifdef max
#undef max
#endif
//! Workaround for compatibility with other libraries
#ifdef min
#undef min
#endif

2
glm/core/func_common.hpp
View File

@ -10,6 +10,8 @@
#ifndef glm_core_func_common
#define glm_core_func_common
#include "_fixes.hpp"
namespace glm
{
namespace test{

2
glm/core/intrinsic_common.hpp
View File

@ -10,7 +10,7 @@
#ifndef glm_detail_intrinsic_common
#define glm_detail_intrinsic_common
#include "../setup.hpp"
#include "setup.hpp"
#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
# error "SSE2 instructions not supported or enabled"

2
glm/core/intrinsic_geometric.hpp
View File

@ -10,7 +10,7 @@
#ifndef glm_core_intrinsic_geometric
#define glm_core_intrinsic_geometric
#include "../setup.hpp"
#include "setup.hpp"
#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
# error "SSE2 instructions not supported or enabled"

1
glm/setup.hpp → glm/core/setup.hpp
View File

@ -365,6 +365,7 @@
# define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
#else
# define GLM_STATIC_ASSERT(x, message)
# define GLM_STATIC_ASSERT_NULL
#endif//GLM_LANG
///////////////////////////////////////////////////////////////////////////////////////////////////

2
glm/core/type_float.hpp
View File

@ -11,7 +11,7 @@
#define glm_core_type_float
#include "type_half.hpp"
#include "../setup.hpp"
#include "setup.hpp"
namespace glm
{

37
glm/core/type_int.hpp
View File

@ -10,33 +10,20 @@
#ifndef glm_core_type_int
#define glm_core_type_int
#include "../setup.hpp"
#include "setup.hpp"
#include "_detail.hpp"
namespace glm
{
namespace detail
{
#if defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_VC)
typedef signed __int64 highp_int_t;
typedef unsigned __int64 highp_uint_t;
#elif(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_GCC))
__extension__ typedef signed long long highp_int_t;
__extension__ typedef unsigned long long highp_uint_t;
//# if GLM_MODEL == GLM_MODEL_64
// typedef signed long highp_int_t;
// typedef unsigned long highp_uint_t;
//# elif GLM_MODEL == GLM_MODEL_32
// __extension__ typedef signed long long highp_int_t;
// __extension__ typedef unsigned long long highp_uint_t;
//# endif//GLM_MODEL
#elif(defined(GLM_COMPILER_BC))
typedef Int64 highp_int_t;
typedef Uint64 highp_uint_t;
#else
typedef signed long long highp_int_t;
typedef unsigned long long highp_uint_t;
#endif//GLM_COMPILER
typedef signed short lowp_int_t;
typedef signed int mediump_int_t;
typedef sint64 highp_int_t;
typedef unsigned short lowp_uint_t;
typedef unsigned int mediump_uint_t;
typedef uint64 highp_uint_t;
GLM_DETAIL_IS_INT(signed char);
GLM_DETAIL_IS_INT(signed short);
@ -49,14 +36,6 @@ namespace glm
GLM_DETAIL_IS_UINT(unsigned int);
GLM_DETAIL_IS_UINT(unsigned long);
GLM_DETAIL_IS_UINT(highp_uint_t);
typedef signed short lowp_int_t;
typedef signed int mediump_int_t;
typedef detail::highp_int_t highp_int_t;
typedef unsigned short lowp_uint_t;
typedef unsigned int mediump_uint_t;
typedef detail::highp_uint_t highp_uint_t;
}
//namespace detail

38
glm/glm.hpp
View File

@ -7,19 +7,11 @@
// File : glm/glm.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "core/_fixes.hpp"
#ifndef glm_glm
#define glm_glm
//! Workaround for compatibility with other libraries
#ifdef max
#undef max
#endif
//! Workaround for compatibility with other libraries
#ifdef min
#undef min
#endif
//! TODO: to delete
#define GLMvalType typename genType::value_type
//#define GLMcolType typename genType::col_type
@ -29,7 +21,7 @@
#include <climits>
#include <cfloat>
#include <limits>
#include "./setup.hpp"
#include "core/setup.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
# define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
@ -95,18 +87,20 @@ namespace glm
////////////////////
// check type sizes
GLM_STATIC_ASSERT(sizeof(glm::detail::int8) == 1, "int8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int16) == 2, "int16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int32) == 4, "int32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int64) == 8, "int64 size isn't 8 bytes on this platform");
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::detail::int8) == 1, "int8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int16) == 2, "int16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int32) == 4, "int32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::int64) == 8, "int64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint8) == 1, "uint8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint8) == 1, "uint8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float16) == 2, "float16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float64) == 8, "float64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float16) == 2, "float16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::detail::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL
#endif //glm_glm

4
glm/gtc/matrix_inverse.inl
View File

@ -8,7 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace gtc{
namespace matrix_inverse
{
template <typename T>
@ -135,5 +135,5 @@ namespace matrix_inverse
}
}//namespace matrix_inverse
}//namespace gtx
}//namespace gtc
}//namespace glm

6
glm/gtc/matrix_transform.inl
View File

@ -332,14 +332,14 @@ namespace matrix_transform
detail::tvec4<U> const & viewport
)
{
assert(delta.x > 0.0f && delta.y > 0.0f)
assert(delta.x > T(0) && delta.y > T(0));
detail::tmat4x4<T> Result(1.0f);
if(!(delta.x > 0.0f && delta.y > 0.0f))
if(!(delta.x > T(0) && delta.y > T(0)))
return Result; // Error
// Translate and scale the picked region to the entire window
Result = translate(Result, (T(viewport[2]) - T(2) * (x - T(viewport[0]))) / delta.x, (T(viewport[3]) - T(2) * (y - T(viewport[1]))) / delta.y, T(0));
Result = translate(Result, (T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x, (T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y, T(0));
return scale(Result, T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1));
}

2
glm/gtc/quaternion.inl
View File

@ -404,7 +404,7 @@ namespace quaternion{
if(flip)
alpha = -alpha;
return normalize(beta * x + alpha * y2);
return normalize(beta * x + alpha * y);
}
template <typename T>

330
glm/gtc/swizzle.hpp
View File

@ -148,113 +148,113 @@ namespace glm
inline detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \
{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
*/
static_swizzle2_const(glm::f16vec2);
static_swizzle2_const(glm::f16vec3);
static_swizzle2_const(glm::f16vec4);
static_swizzle2_const(glm::f32vec2);
static_swizzle2_const(glm::f32vec3);
static_swizzle2_const(glm::f32vec4);
static_swizzle2_const(glm::f64vec2);
static_swizzle2_const(glm::f64vec3);
static_swizzle2_const(glm::f64vec4);
static_swizzle2_const(glm::f16vec2)
static_swizzle2_const(glm::f16vec3)
static_swizzle2_const(glm::f16vec4)
static_swizzle2_const(glm::f32vec2)
static_swizzle2_const(glm::f32vec3)
static_swizzle2_const(glm::f32vec4)
static_swizzle2_const(glm::f64vec2)
static_swizzle2_const(glm::f64vec3)
static_swizzle2_const(glm::f64vec4)
static_swizzle2_const(glm::i8vec2);
static_swizzle2_const(glm::i8vec3);
static_swizzle2_const(glm::i8vec4);
static_swizzle2_const(glm::i16vec2);
static_swizzle2_const(glm::i16vec3);
static_swizzle2_const(glm::i16vec4);
static_swizzle2_const(glm::i32vec2);
static_swizzle2_const(glm::i32vec3);
static_swizzle2_const(glm::i32vec4);
static_swizzle2_const(glm::i64vec2);
static_swizzle2_const(glm::i64vec3);
static_swizzle2_const(glm::i64vec4);
static_swizzle2_const(glm::i8vec2)
static_swizzle2_const(glm::i8vec3)
static_swizzle2_const(glm::i8vec4)
static_swizzle2_const(glm::i16vec2)
static_swizzle2_const(glm::i16vec3)
static_swizzle2_const(glm::i16vec4)
static_swizzle2_const(glm::i32vec2)
static_swizzle2_const(glm::i32vec3)
static_swizzle2_const(glm::i32vec4)
static_swizzle2_const(glm::i64vec2)
static_swizzle2_const(glm::i64vec3)
static_swizzle2_const(glm::i64vec4)
static_swizzle2_const(glm::u8vec2);
static_swizzle2_const(glm::u8vec3);
static_swizzle2_const(glm::u8vec4);
static_swizzle2_const(glm::u16vec2);
static_swizzle2_const(glm::u16vec3);
static_swizzle2_const(glm::u16vec4);
static_swizzle2_const(glm::u32vec2);
static_swizzle2_const(glm::u32vec3);
static_swizzle2_const(glm::u32vec4);
static_swizzle2_const(glm::u64vec2);
static_swizzle2_const(glm::u64vec3);
static_swizzle2_const(glm::u64vec4);
static_swizzle2_const(glm::u8vec2)
static_swizzle2_const(glm::u8vec3)
static_swizzle2_const(glm::u8vec4)
static_swizzle2_const(glm::u16vec2)
static_swizzle2_const(glm::u16vec3)
static_swizzle2_const(glm::u16vec4)
static_swizzle2_const(glm::u32vec2)
static_swizzle2_const(glm::u32vec3)
static_swizzle2_const(glm::u32vec4)
static_swizzle2_const(glm::u64vec2)
static_swizzle2_const(glm::u64vec3)
static_swizzle2_const(glm::u64vec4)
static_swizzle3_const(glm::f16vec2);
static_swizzle3_const(glm::f16vec3);
static_swizzle3_const(glm::f16vec4);
static_swizzle3_const(glm::f32vec2);
static_swizzle3_const(glm::f32vec3);
static_swizzle3_const(glm::f32vec4);
static_swizzle3_const(glm::f64vec2);
static_swizzle3_const(glm::f64vec3);
static_swizzle3_const(glm::f64vec4);
static_swizzle3_const(glm::f16vec2)
static_swizzle3_const(glm::f16vec3)
static_swizzle3_const(glm::f16vec4)
static_swizzle3_const(glm::f32vec2)
static_swizzle3_const(glm::f32vec3)
static_swizzle3_const(glm::f32vec4)
static_swizzle3_const(glm::f64vec2)
static_swizzle3_const(glm::f64vec3)
static_swizzle3_const(glm::f64vec4)
static_swizzle3_const(glm::i8vec2);
static_swizzle3_const(glm::i8vec3);
static_swizzle3_const(glm::i8vec4);
static_swizzle3_const(glm::i16vec2);
static_swizzle3_const(glm::i16vec3);
static_swizzle3_const(glm::i16vec4);
static_swizzle3_const(glm::i32vec2);
static_swizzle3_const(glm::i32vec3);
static_swizzle3_const(glm::i32vec4);
static_swizzle3_const(glm::i64vec2);
static_swizzle3_const(glm::i64vec3);
static_swizzle3_const(glm::i64vec4);
static_swizzle3_const(glm::i8vec2)
static_swizzle3_const(glm::i8vec3)
static_swizzle3_const(glm::i8vec4)
static_swizzle3_const(glm::i16vec2)
static_swizzle3_const(glm::i16vec3)
static_swizzle3_const(glm::i16vec4)
static_swizzle3_const(glm::i32vec2)
static_swizzle3_const(glm::i32vec3)
static_swizzle3_const(glm::i32vec4)
static_swizzle3_const(glm::i64vec2)
static_swizzle3_const(glm::i64vec3)
static_swizzle3_const(glm::i64vec4)
static_swizzle3_const(glm::u8vec2);
static_swizzle3_const(glm::u8vec3);
static_swizzle3_const(glm::u8vec4);
static_swizzle3_const(glm::u16vec2);
static_swizzle3_const(glm::u16vec3);
static_swizzle3_const(glm::u16vec4);
static_swizzle3_const(glm::u32vec2);
static_swizzle3_const(glm::u32vec3);
static_swizzle3_const(glm::u32vec4);
static_swizzle3_const(glm::u64vec2);
static_swizzle3_const(glm::u64vec3);
static_swizzle3_const(glm::u64vec4);
static_swizzle3_const(glm::u8vec2)
static_swizzle3_const(glm::u8vec3)
static_swizzle3_const(glm::u8vec4)
static_swizzle3_const(glm::u16vec2)
static_swizzle3_const(glm::u16vec3)
static_swizzle3_const(glm::u16vec4)
static_swizzle3_const(glm::u32vec2)
static_swizzle3_const(glm::u32vec3)
static_swizzle3_const(glm::u32vec4)
static_swizzle3_const(glm::u64vec2)
static_swizzle3_const(glm::u64vec3)
static_swizzle3_const(glm::u64vec4)
static_swizzle4_const(glm::f16vec2);
static_swizzle4_const(glm::f16vec3);
static_swizzle4_const(glm::f16vec4);
static_swizzle4_const(glm::f32vec2);
static_swizzle4_const(glm::f32vec3);
static_swizzle4_const(glm::f32vec4);
static_swizzle4_const(glm::f64vec2);
static_swizzle4_const(glm::f64vec3);
static_swizzle4_const(glm::f64vec4);
static_swizzle4_const(glm::f16vec2)
static_swizzle4_const(glm::f16vec3)
static_swizzle4_const(glm::f16vec4)
static_swizzle4_const(glm::f32vec2)
static_swizzle4_const(glm::f32vec3)
static_swizzle4_const(glm::f32vec4)
static_swizzle4_const(glm::f64vec2)
static_swizzle4_const(glm::f64vec3)
static_swizzle4_const(glm::f64vec4)
static_swizzle4_const(glm::i8vec2);
static_swizzle4_const(glm::i8vec3);
static_swizzle4_const(glm::i8vec4);
static_swizzle4_const(glm::i16vec2);
static_swizzle4_const(glm::i16vec3);
static_swizzle4_const(glm::i16vec4);
static_swizzle4_const(glm::i32vec2);
static_swizzle4_const(glm::i32vec3);
static_swizzle4_const(glm::i32vec4);
static_swizzle4_const(glm::i64vec2);
static_swizzle4_const(glm::i64vec3);
static_swizzle4_const(glm::i64vec4);
static_swizzle4_const(glm::i8vec2)
static_swizzle4_const(glm::i8vec3)
static_swizzle4_const(glm::i8vec4)
static_swizzle4_const(glm::i16vec2)
static_swizzle4_const(glm::i16vec3)
static_swizzle4_const(glm::i16vec4)
static_swizzle4_const(glm::i32vec2)
static_swizzle4_const(glm::i32vec3)
static_swizzle4_const(glm::i32vec4)
static_swizzle4_const(glm::i64vec2)
static_swizzle4_const(glm::i64vec3)
static_swizzle4_const(glm::i64vec4)
static_swizzle4_const(glm::u8vec2);
static_swizzle4_const(glm::u8vec3);
static_swizzle4_const(glm::u8vec4);
static_swizzle4_const(glm::u16vec2);
static_swizzle4_const(glm::u16vec3);
static_swizzle4_const(glm::u16vec4);
static_swizzle4_const(glm::u32vec2);
static_swizzle4_const(glm::u32vec3);
static_swizzle4_const(glm::u32vec4);
static_swizzle4_const(glm::u64vec2);
static_swizzle4_const(glm::u64vec3);
static_swizzle4_const(glm::u64vec4);
static_swizzle4_const(glm::u8vec2)
static_swizzle4_const(glm::u8vec3)
static_swizzle4_const(glm::u8vec4)
static_swizzle4_const(glm::u16vec2)
static_swizzle4_const(glm::u16vec3)
static_swizzle4_const(glm::u16vec4)
static_swizzle4_const(glm::u32vec2)
static_swizzle4_const(glm::u32vec3)
static_swizzle4_const(glm::u32vec4)
static_swizzle4_const(glm::u64vec2)
static_swizzle4_const(glm::u64vec3)
static_swizzle4_const(glm::u64vec4)
# define static_swizzle2_ref(TYPE) \
template <glm::comp x, glm::comp y> \
@ -271,80 +271,80 @@ namespace glm
inline glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \
{return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);}
static_swizzle2_ref(glm::f16vec2);
static_swizzle2_ref(glm::f16vec3);
static_swizzle2_ref(glm::f16vec4);
static_swizzle2_ref(glm::f32vec2);
static_swizzle2_ref(glm::f32vec3);
static_swizzle2_ref(glm::f32vec4);
static_swizzle2_ref(glm::f64vec2);
static_swizzle2_ref(glm::f64vec3);
static_swizzle2_ref(glm::f64vec4);
static_swizzle2_ref(glm::f16vec2)
static_swizzle2_ref(glm::f16vec3)
static_swizzle2_ref(glm::f16vec4)
static_swizzle2_ref(glm::f32vec2)
static_swizzle2_ref(glm::f32vec3)
static_swizzle2_ref(glm::f32vec4)
static_swizzle2_ref(glm::f64vec2)
static_swizzle2_ref(glm::f64vec3)
static_swizzle2_ref(glm::f64vec4)
static_swizzle2_ref(glm::i8vec2);
static_swizzle2_ref(glm::i8vec3);
static_swizzle2_ref(glm::i8vec4);
static_swizzle2_ref(glm::i16vec2);
static_swizzle2_ref(glm::i16vec3);
static_swizzle2_ref(glm::i16vec4);
static_swizzle2_ref(glm::i32vec2);
static_swizzle2_ref(glm::i32vec3);
static_swizzle2_ref(glm::i32vec4);
static_swizzle2_ref(glm::i64vec2);
static_swizzle2_ref(glm::i64vec3);
static_swizzle2_ref(glm::i64vec4);
static_swizzle2_ref(glm::i8vec2)
static_swizzle2_ref(glm::i8vec3)
static_swizzle2_ref(glm::i8vec4)
static_swizzle2_ref(glm::i16vec2)
static_swizzle2_ref(glm::i16vec3)
static_swizzle2_ref(glm::i16vec4)
static_swizzle2_ref(glm::i32vec2)
static_swizzle2_ref(glm::i32vec3)
static_swizzle2_ref(glm::i32vec4)
static_swizzle2_ref(glm::i64vec2)
static_swizzle2_ref(glm::i64vec3)
static_swizzle2_ref(glm::i64vec4)
static_swizzle2_ref(glm::u8vec2);
static_swizzle2_ref(glm::u8vec3);
static_swizzle2_ref(glm::u8vec4);
static_swizzle2_ref(glm::u16vec2);
static_swizzle2_ref(glm::u16vec3);
static_swizzle2_ref(glm::u16vec4);
static_swizzle2_ref(glm::u32vec2);
static_swizzle2_ref(glm::u32vec3);
static_swizzle2_ref(glm::u32vec4);
static_swizzle2_ref(glm::u64vec2);
static_swizzle2_ref(glm::u64vec3);
static_swizzle2_ref(glm::u64vec4);
static_swizzle2_ref(glm::u8vec2)
static_swizzle2_ref(glm::u8vec3)
static_swizzle2_ref(glm::u8vec4)
static_swizzle2_ref(glm::u16vec2)
static_swizzle2_ref(glm::u16vec3)
static_swizzle2_ref(glm::u16vec4)
static_swizzle2_ref(glm::u32vec2)
static_swizzle2_ref(glm::u32vec3)
static_swizzle2_ref(glm::u32vec4)
static_swizzle2_ref(glm::u64vec2)
static_swizzle2_ref(glm::u64vec3)
static_swizzle2_ref(glm::u64vec4)
static_swizzle3_ref(glm::f16vec3);
static_swizzle3_ref(glm::f16vec4);
static_swizzle3_ref(glm::f32vec3);
static_swizzle3_ref(glm::f32vec4);
static_swizzle3_ref(glm::f64vec3);
static_swizzle3_ref(glm::f64vec4);
static_swizzle3_ref(glm::f16vec3)
static_swizzle3_ref(glm::f16vec4)
static_swizzle3_ref(glm::f32vec3)
static_swizzle3_ref(glm::f32vec4)
static_swizzle3_ref(glm::f64vec3)
static_swizzle3_ref(glm::f64vec4)
static_swizzle3_ref(glm::i8vec3);
static_swizzle3_ref(glm::i8vec4);
static_swizzle3_ref(glm::i16vec3);
static_swizzle3_ref(glm::i16vec4);
static_swizzle3_ref(glm::i32vec3);
static_swizzle3_ref(glm::i32vec4);
static_swizzle3_ref(glm::i64vec3);
static_swizzle3_ref(glm::i64vec4);
static_swizzle3_ref(glm::i8vec3)
static_swizzle3_ref(glm::i8vec4)
static_swizzle3_ref(glm::i16vec3)
static_swizzle3_ref(glm::i16vec4)
static_swizzle3_ref(glm::i32vec3)
static_swizzle3_ref(glm::i32vec4)
static_swizzle3_ref(glm::i64vec3)
static_swizzle3_ref(glm::i64vec4)
static_swizzle3_ref(glm::u8vec3);
static_swizzle3_ref(glm::u8vec4);
static_swizzle3_ref(glm::u16vec3);
static_swizzle3_ref(glm::u16vec4);
static_swizzle3_ref(glm::u32vec3);
static_swizzle3_ref(glm::u32vec4);
static_swizzle3_ref(glm::u64vec3);
static_swizzle3_ref(glm::u64vec4);
static_swizzle3_ref(glm::u8vec3)
static_swizzle3_ref(glm::u8vec4)
static_swizzle3_ref(glm::u16vec3)
static_swizzle3_ref(glm::u16vec4)
static_swizzle3_ref(glm::u32vec3)
static_swizzle3_ref(glm::u32vec4)
static_swizzle3_ref(glm::u64vec3)
static_swizzle3_ref(glm::u64vec4)
static_swizzle4_ref(glm::f16vec4);
static_swizzle4_ref(glm::f32vec4);
static_swizzle4_ref(glm::f64vec4);
static_swizzle4_ref(glm::f16vec4)
static_swizzle4_ref(glm::f32vec4)
static_swizzle4_ref(glm::f64vec4)
static_swizzle4_ref(glm::i8vec4);
static_swizzle4_ref(glm::i16vec4);
static_swizzle4_ref(glm::i32vec4);
static_swizzle4_ref(glm::i64vec4);
static_swizzle4_ref(glm::i8vec4)
static_swizzle4_ref(glm::i16vec4)
static_swizzle4_ref(glm::i32vec4)
static_swizzle4_ref(glm::i64vec4)
static_swizzle4_ref(glm::u8vec4);
static_swizzle4_ref(glm::u16vec4);
static_swizzle4_ref(glm::u32vec4);
static_swizzle4_ref(glm::u64vec4);
static_swizzle4_ref(glm::u8vec4)
static_swizzle4_ref(glm::u16vec4)
static_swizzle4_ref(glm::u32vec4)
static_swizzle4_ref(glm::u64vec4)
}//namespace swizzle
}//namespace gtc

2
glm/gtx/simd_mat4.hpp
View File

@ -34,7 +34,7 @@ namespace glm
{
/// 4x4 Matrix implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_mat4
GLM_ALIGN(16) struct fmat4x4SIMD
GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
{
enum ctor{null};

2
glm/gtx/simd_vec4.hpp
View File

@ -34,7 +34,7 @@ namespace glm
{
/// 4-dimensional vector implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGN(4) struct fvec4SIMD
GLM_ALIGNED_STRUCT(4) fvec4SIMD
{
enum ctor{null};
typedef __m128 value_type;

7
test/CMakeLists.txt
View File

@ -1,8 +1,11 @@
function(glmCreateTestGTC NAME)
set(SAMPLE_NAME test-${NAME})
add_executable(${SAMPLE_NAME} ${NAME}.cpp ../test.hpp ../test.cpp)
endfunction(glmCreateTestGTC)
#For GLM 0.9.2, not ready yet
#add_test(
# NAME ${SAMPLE_NAME}
# COMMAND $<TARGET_FILE:${SAMPLE_NAME}> )
endfunction()
add_subdirectory(bug)
add_subdirectory(core)