Browse Source

光线追踪基础框架

master
ubuntu20 4 years ago
parent
commit
6d06ce6640
  1. BIN
      Debug/Scene.obj
  2. BIN
      Debug/main.obj
  3. BIN
      Debug/raytracing.exe
  4. BIN
      Debug/raytracing.ilk
  5. 4
      Debug/raytracing.log
  6. BIN
      Debug/raytracing.pdb
  7. BIN
      Debug/raytracing.tlog/CL.command.1.tlog
  8. BIN
      Debug/raytracing.tlog/CL.read.1.tlog
  9. BIN
      Debug/raytracing.tlog/CL.write.1.tlog
  10. BIN
      Debug/raytracing.tlog/link.command.1.tlog
  11. BIN
      Debug/raytracing.tlog/link.read.1.tlog
  12. BIN
      Debug/raytracing.tlog/link.write.1.tlog
  13. 2
      Debug/raytracing.tlog/raytracing.lastbuildstate
  14. BIN
      Debug/util.obj
  15. BIN
      Debug/vc141.idb
  16. BIN
      Debug/vc141.pdb
  17. 43
      Glm/CMakeLists.txt
  18. 482
      Glm/core/_detail.hpp
  19. 55
      Glm/core/_fixes.hpp
  20. 861
      Glm/core/_swizzle.hpp
  21. 787
      Glm/core/_swizzle_func.hpp
  22. 159
      Glm/core/_vectorize.hpp
  23. 35
      Glm/core/dummy.cpp
  24. 430
      Glm/core/func_common.hpp
  25. 1226
      Glm/core/func_common.inl
  26. 123
      Glm/core/func_exponential.hpp
  27. 156
      Glm/core/func_exponential.inl
  28. 138
      Glm/core/func_geometric.hpp
  29. 321
      Glm/core/func_geometric.inl
  30. 201
      Glm/core/func_integer.hpp
  31. 648
      Glm/core/func_integer.inl
  32. 150
      Glm/core/func_matrix.hpp
  33. 582
      Glm/core/func_matrix.inl
  34. 87
      Glm/core/func_noise.hpp
  35. 364
      Glm/core/func_noise.inl
  36. 193
      Glm/core/func_packing.hpp
  37. 208
      Glm/core/func_packing.inl
  38. 203
      Glm/core/func_trigonometric.hpp
  39. 244
      Glm/core/func_trigonometric.inl
  40. 138
      Glm/core/func_vector_relational.hpp
  41. 178
      Glm/core/func_vector_relational.inl
  42. 40
      Glm/core/hint.hpp
  43. 89
      Glm/core/intrinsic_common.hpp
  44. 313
      Glm/core/intrinsic_common.inl
  45. 79
      Glm/core/intrinsic_exponential.hpp
  46. 27
      Glm/core/intrinsic_exponential.inl
  47. 76
      Glm/core/intrinsic_geometric.hpp
  48. 146
      Glm/core/intrinsic_geometric.inl
  49. 69
      Glm/core/intrinsic_matrix.hpp
  50. 1070
      Glm/core/intrinsic_matrix.inl
  51. 48
      Glm/core/intrinsic_trigonometric.hpp
  52. 27
      Glm/core/intrinsic_trigonometric.inl
  53. 48
      Glm/core/intrinsic_vector_relational.hpp
  54. 366
      Glm/core/intrinsic_vector_relational.inl
  55. 694
      Glm/core/setup.hpp
  56. 341
      Glm/core/type.hpp
  57. 84
      Glm/core/type_float.hpp
  58. 169
      Glm/core/type_gentype.hpp
  59. 366
      Glm/core/type_gentype.inl
  60. 118
      Glm/core/type_half.hpp
  61. 421
      Glm/core/type_half.inl
  62. 142
      Glm/core/type_int.hpp
  63. 41
      Glm/core/type_mat.hpp
  64. 27
      Glm/core/type_mat.inl
  65. 314
      Glm/core/type_mat2x2.hpp
  66. 688
      Glm/core/type_mat2x2.inl
  67. 258
      Glm/core/type_mat2x3.hpp
  68. 633
      Glm/core/type_mat2x3.inl
  69. 260
      Glm/core/type_mat2x4.hpp
  70. 652
      Glm/core/type_mat2x4.inl
  71. 265
      Glm/core/type_mat3x2.hpp
  72. 670
      Glm/core/type_mat3x2.inl
  73. 318
      Glm/core/type_mat3x3.hpp
  74. 800
      Glm/core/type_mat3x3.inl
  75. 266
      Glm/core/type_mat3x4.hpp
  76. 700
      Glm/core/type_mat3x4.inl
  77. 270
      Glm/core/type_mat4x2.hpp
  78. 716
      Glm/core/type_mat4x2.inl
  79. 268
      Glm/core/type_mat4x3.hpp
  80. 725
      Glm/core/type_mat4x3.inl
  81. 320
      Glm/core/type_mat4x4.hpp
  82. 893
      Glm/core/type_mat4x4.inl
  83. 43
      Glm/core/type_size.hpp
  84. 41
      Glm/core/type_vec.hpp
  85. 27
      Glm/core/type_vec.inl
  86. 212
      Glm/core/type_vec1.hpp
  87. 928
      Glm/core/type_vec1.inl
  88. 317
      Glm/core/type_vec2.hpp
  89. 998
      Glm/core/type_vec2.inl
  90. 342
      Glm/core/type_vec3.hpp
  91. 1122
      Glm/core/type_vec3.inl
  92. 399
      Glm/core/type_vec4.hpp
  93. 1348
      Glm/core/type_vec4.inl
  94. 145
      Glm/ext.hpp
  95. 129
      Glm/glm.hpp
  96. 186
      Glm/gtc/constants.hpp
  97. 186
      Glm/gtc/constants.inl
  98. 94
      Glm/gtc/epsilon.hpp
  99. 286
      Glm/gtc/epsilon.inl
  100. 454
      Glm/gtc/half_float.hpp

BIN
Debug/Scene.obj

BIN
Debug/main.obj

BIN
Debug/raytracing.exe

BIN
Debug/raytracing.ilk

4
Debug/raytracing.log

@ -0,0 +1,4 @@
 raytracing.vcxproj -> D:\dev\cpp\raytracing\Debug\raytracing.exe
Microsoft (R) COFF/PE Editor Version 14.16.27043.0
Copyright (C) Microsoft Corporation. All rights reserved.

BIN
Debug/raytracing.pdb

BIN
Debug/raytracing.tlog/CL.command.1.tlog

BIN
Debug/raytracing.tlog/CL.read.1.tlog

BIN
Debug/raytracing.tlog/CL.write.1.tlog

BIN
Debug/raytracing.tlog/link.command.1.tlog

BIN
Debug/raytracing.tlog/link.read.1.tlog

BIN
Debug/raytracing.tlog/link.write.1.tlog

2
Debug/raytracing.tlog/raytracing.lastbuildstate

@ -0,0 +1,2 @@
#TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0
Debug|Win32|D:\dev\cpp\raytracing\|

BIN
Debug/util.obj

BIN
Debug/vc141.idb

BIN
Debug/vc141.pdb

43
Glm/CMakeLists.txt

@ -0,0 +1,43 @@
set(NAME glm)
file(GLOB ROOT_SOURCE *.cpp)
file(GLOB ROOT_INLINE *.inl)
file(GLOB ROOT_HEADER *.hpp)
file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp)
file(GLOB_RECURSE CORE_INLINE ./core/*.inl)
file(GLOB_RECURSE CORE_HEADER ./core/*.hpp)
file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
file(GLOB_RECURSE VIRTREV_SOURCE ./virtrev/*.cpp)
file(GLOB_RECURSE VIRTREV_INLINE ./virtrev/*.inl)
file(GLOB_RECURSE VIRTREV_HEADER ./virtrev/*.hpp)
source_group("Core Files" FILES ${CORE_SOURCE})
source_group("Core Files" FILES ${CORE_INLINE})
source_group("Core Files" FILES ${CORE_HEADER})
source_group("GTC Files" FILES ${GTC_SOURCE})
source_group("GTC Files" FILES ${GTC_INLINE})
source_group("GTC Files" FILES ${GTC_HEADER})
source_group("GTX Files" FILES ${GTX_SOURCE})
source_group("GTX Files" FILES ${GTX_INLINE})
source_group("GTX Files" FILES ${GTX_HEADER})
source_group("VIRTREV Files" FILES ${VIRTREV_SOURCE})
source_group("VIRTREV Files" FILES ${VIRTREV_INLINE})
source_group("VIRTREV Files" FILES ${VIRTREV_HEADER})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
add_executable(${NAME}
${ROOT_SOURCE} ${ROOT_INLINE} ${ROOT_HEADER}
${CORE_SOURCE} ${CORE_INLINE} ${CORE_HEADER}
${GTC_SOURCE} ${GTC_INLINE} ${GTC_HEADER}
${GTX_SOURCE} ${GTX_INLINE} ${GTX_HEADER}
${VIRTREV_SOURCE} ${VIRTREV_INLINE} ${VIRTREV_HEADER})

482
Glm/core/_detail.hpp

@ -0,0 +1,482 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_detail.hpp
/// @date 2008-07-24 / 2011-06-14
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_detail
#define glm_core_detail
#include "setup.hpp"
#include <cassert>
#if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
#include <cstdint>
#endif
namespace glm{
namespace detail
{
class half;
#if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
typedef int64_t sint64;
typedef uint64_t uint64;
#elif(GLM_COMPILER & GLM_COMPILER_VC)
typedef signed __int64 sint64;
typedef unsigned __int64 uint64;
#elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
__extension__ typedef signed long long sint64;
__extension__ typedef unsigned long long uint64;
#elif(GLM_COMPILER & GLM_COMPILER_BC)
typedef Int64 sint64;
typedef Uint64 uint64;
#else//unknown compiler
typedef signed long long sint64;
typedef unsigned long long uint64;
#endif//GLM_COMPILER
template<bool C>
struct If
{
template<typename F, typename T>
static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
{
return functor(val);
}
};
template<>
struct If<false>
{
template<typename F, typename T>
static GLM_FUNC_QUALIFIER T apply(F, const T& val)
{
return val;
}
};
//template <typename T>
//struct traits
//{
// static const bool is_signed = false;
// static const bool is_float = false;
// static const bool is_vector = false;
// static const bool is_matrix = false;
// static const bool is_genType = false;
// static const bool is_genIType = false;
// static const bool is_genUType = false;
//};
//template <>
//struct traits<half>
//{
// static const bool is_float = true;
// static const bool is_genType = true;
//};
//template <>
//struct traits<float>
//{
// static const bool is_float = true;
// static const bool is_genType = true;
//};
//template <>
//struct traits<double>
//{
// static const bool is_float = true;
// static const bool is_genType = true;
//};
//template <typename genType>
//struct desc
//{
// typedef genType type;
// typedef genType * pointer;
// typedef genType const* const_pointer;
// typedef genType const *const const_pointer_const;
// typedef genType *const pointer_const;
// typedef genType & reference;
// typedef genType const& const_reference;
// typedef genType const& param_type;
// typedef typename genType::value_type value_type;
// typedef typename genType::size_type size_type;
// static const typename size_type value_size;
//};
//template <typename genType>
//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
union uif32
{
GLM_FUNC_QUALIFIER uif32() :
i(0)
{}
GLM_FUNC_QUALIFIER uif32(float f) :
f(f)
{}
GLM_FUNC_QUALIFIER uif32(unsigned int i) :
i(i)
{}
float f;
unsigned int i;
};
union uif64
{
GLM_FUNC_QUALIFIER uif64() :
i(0)
{}
GLM_FUNC_QUALIFIER uif64(double f) :
f(f)
{}
GLM_FUNC_QUALIFIER uif64(uint64 i) :
i(i)
{}
double f;
uint64 i;
};
typedef uif32 uif;
//////////////////
// int
template <typename T>
struct is_int
{
enum is_int_enum
{
_YES = 0,
_NO = 1
};
};
#define GLM_DETAIL_IS_INT(T) \
template <> \
struct is_int<T> \
{ \
enum is_int_enum \
{ \
_YES = 1, \
_NO = 0 \
}; \
}
//////////////////
// uint
template <typename T>
struct is_uint
{
enum is_uint_enum
{
_YES = 0,
_NO = 1
};
};
#define GLM_DETAIL_IS_UINT(T) \
template <> \
struct is_uint<T> \
{ \
enum is_uint_enum \
{ \
_YES = 1, \
_NO = 0 \
}; \
}
//GLM_DETAIL_IS_UINT(unsigned long long)
//////////////////
// float
template <typename T>
struct is_float
{
enum is_float_enum
{
_YES = 0,
_NO = 1
};
};
#define GLM_DETAIL_IS_FLOAT(T) \
template <> \
struct is_float<T> \
{ \
enum is_float_enum \
{ \
_YES = 1, \
_NO = 0 \
}; \
}
GLM_DETAIL_IS_FLOAT(detail::half);
GLM_DETAIL_IS_FLOAT(float);
GLM_DETAIL_IS_FLOAT(double);
GLM_DETAIL_IS_FLOAT(long double);
//////////////////
// bool
template <typename T>
struct is_bool
{
enum is_bool_enum
{
_YES = 0,
_NO = 1
};
};
template <>
struct is_bool<bool>
{
enum is_bool_enum
{
_YES = 1,
_NO = 0
};
};
//////////////////
// vector
template <typename T>
struct is_vector
{
enum is_vector_enum
{
_YES = 0,
_NO = 1
};
};
# define GLM_DETAIL_IS_VECTOR(TYPE) \
template <typename T> \
struct is_vector<TYPE<T> > \
{ \
enum is_vector_enum \
{ \
_YES = 1, \
_NO = 0 \
}; \
}
//////////////////
// matrix
template <typename T>
struct is_matrix
{
enum is_matrix_enum
{
_YES = 0,
_NO = 1
};
};
#define GLM_DETAIL_IS_MATRIX(T) \
template <> \
struct is_matrix \
{ \
enum is_matrix_enum \
{ \
_YES = 1, \
_NO = 0 \
}; \
}
//////////////////
// type
template <typename T>
struct type
{
enum type_enum
{
is_float = is_float<T>::_YES,
is_int = is_int<T>::_YES,
is_uint = is_uint<T>::_YES,
is_bool = is_bool<T>::_YES
};
};
//////////////////
// type
typedef signed char int8;
typedef signed short int16;
typedef signed int int32;
typedef detail::sint64 int64;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef detail::uint64 uint64;
typedef detail::half float16;
typedef float float32;
typedef double float64;
//////////////////
// float_or_int_trait
struct float_or_int_value
{
enum
{
GLM_ERROR,
GLM_FLOAT,
GLM_INT
};
};
template <typename T>
struct float_or_int_trait
{
enum{ID = float_or_int_value::GLM_ERROR};
};
template <>
struct float_or_int_trait<int8>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<int16>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<int32>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<int64>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<uint8>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<uint16>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<uint32>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<uint64>
{
enum{ID = float_or_int_value::GLM_INT};
};
template <>
struct float_or_int_trait<float16>
{
enum{ID = float_or_int_value::GLM_FLOAT};
};
template <>
struct float_or_int_trait<float32>
{
enum{ID = float_or_int_value::GLM_FLOAT};
};
template <>
struct float_or_int_trait<float64>
{
enum{ID = float_or_int_value::GLM_FLOAT};
};
}//namespace detail
}//namespace glm
#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
# define GLM_CONSTEXPR
#elif(GLM_COMPILER & GLM_COMPILER_INTEL)
# define GLM_DEPRECATED
# define GLM_ALIGN(x) __declspec(align(x))
# define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
# define GLM_RESTRICT
# define GLM_RESTRICT_VAR __restrict
# define GLM_CONSTEXPR
#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) || (GLM_COMPILER & GLM_COMPILER_CLANG))
# define GLM_DEPRECATED __attribute__((__deprecated__))
# 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__
# else
# define GLM_RESTRICT
# define GLM_RESTRICT_VAR
# endif
# define GLM_RESTRICT __restrict__
# define GLM_RESTRICT_VAR __restrict__
# if((GLM_COMPILER >= GLM_COMPILER_GCC47) && ((GLM_LANG & GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
# define GLM_CONSTEXPR constexpr
# else
# define GLM_CONSTEXPR
# endif
#else
# define GLM_DEPRECATED
# define GLM_ALIGN
# define GLM_ALIGNED_STRUCT(x)
# define GLM_RESTRICT
# define GLM_RESTRICT_VAR
# define GLM_CONSTEXPR
#endif//GLM_COMPILER
#endif//glm_core_detail

55
Glm/core/_fixes.hpp

@ -0,0 +1,55 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_fixes.hpp
/// @date 2011-02-21 / 2011-11-22
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include <cmath>
//! Workaround for compatibility with other libraries
#ifdef max
#undef max
#endif
//! Workaround for compatibility with other libraries
#ifdef min
#undef min
#endif
//! Workaround for Android
#ifdef isnan
#undef isnan
#endif
//! Workaround for Android
#ifdef isinf
#undef isinf
#endif
//! Workaround for Chrone Native Client
#ifdef log2
#undef log2
#endif

861
Glm/core/_swizzle.hpp

@ -0,0 +1,861 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_swizzle.hpp
/// @date 2006-04-20 / 2011-02-16
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_swizzle
#define glm_core_swizzle
#include "_swizzle_func.hpp"
namespace glm
{
enum comp
{
X = 0,
R = 0,
S = 0,
Y = 1,
G = 1,
T = 1,
Z = 2,
B = 2,
P = 2,
W = 3,
A = 3,
Q = 3
};
}//namespace glm
namespace glm{
namespace detail
{
// Internal class for implementing swizzle operators
template <typename T, int N>
struct _swizzle_base0
{
typedef T value_type;
protected:
GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast<value_type*>(_buffer))[i]; }
GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
// The size 1 buffer is assumed to aligned to the actual members so that the
// elem()
char _buffer[1];
};
template <typename T, typename V, int E0, int E1, int E2, int E3, int N>
struct _swizzle_base1 : public _swizzle_base0<T,N>
{
};
template <typename T, typename V, int E0, int E1>
struct _swizzle_base1<T,V,E0,E1,-1,-2,2> : public _swizzle_base0<T,2>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); }
};
template <typename T, typename V, int E0, int E1, int E2>
struct _swizzle_base1<T,V,E0,E1,E2,-1,3> : public _swizzle_base0<T,3>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
};
template <typename T, typename V, int E0, int E1, int E2, int E3>
struct _swizzle_base1<T,V,E0,E1,E2,E3,4> : public _swizzle_base0<T,4>
{
GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
};
// Internal class for implementing swizzle operators
/*
Template parameters:
ValueType = type of scalar values (e.g. float, double)
VecType = class the swizzle is applies to (e.g. tvec3<float>)
N = number of components in the vector (e.g. 3)
E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec
DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
containing duplicate elements so that they cannot be used as r-values).
*/
template <typename ValueType, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
struct _swizzle_base2 : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
{
typedef VecType vec_type;
typedef ValueType value_type;
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
{
for (int i = 0; i < N; ++i)
(*this)[i] = t;
return *this;
}
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; }
};
_apply_op(that, op());
return *this;
}
GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator += (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
{
struct op {
GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; }
};
_apply_op(that, op());
}
GLM_FUNC_QUALIFIER value_type& operator[] (size_t i)
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
protected:
template <typename T>
GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
{
// Make a copy of the data in this == &that.
// The copier should optimize out the copy in cases where the function is
// properly inlined and the copy is not necessary.
ValueType t[N];
for (int i = 0; i < N; ++i)
t[i] = that[i];
for (int i = 0; i < N; ++i)
op( (*this)[i], t[i] );
}
};
// Specialization for swizzles containing duplicate elements. These cannot be modified.
template <typename ValueType, typename VecType, int N, int E0, int E1, int E2, int E3>
struct _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
{
typedef VecType vec_type;
typedef ValueType value_type;
struct Stub {};
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const
{
#ifndef __CUDA_ARCH__
static
#endif
const int offset_dst[4] = { E0, E1, E2, E3 };
return this->elem(offset_dst[i]);
}
};
template <int N,typename ValueType, typename VecType, int E0,int E1,int E2,int E3>
struct swizzle : public _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
{
typedef _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
using base_type::operator=;
GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
};
//
// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
//
#define _GLM_SWIZZLE_TEMPLATE1 template <int N, typename T, typename V, int E0, int E1, int E2, int E3>
#define _GLM_SWIZZLE_TEMPLATE2 template <int N, typename T, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
#define _GLM_SWIZZLE_TYPE1 glm::detail::swizzle<N,T,V,E0,E1,E2,E3>
#define _GLM_SWIZZLE_TYPE2 glm::detail::swizzle<N,T,V,F0,F1,F2,F3>
//
// Wrapper for a binary operator (e.g. u.yy + v.zy)
//
#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
{ \
return a() OPERAND b(); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \
{ \
return a() OPERAND b; \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return a OPERAND b(); \
}
//
// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
//
#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \
{ \
return a() OPERAND b; \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return a OPERAND b(); \
}
//
// Macro for wrapping a function taking one argument (e.g. abs())
//
#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \
{ \
return FUNCTION(a()); \
}
//
// Macro for wrapping a function taking two vector arguments (e.g. dot()).
//
#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
{ \
return FUNCTION(a(), b()); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return FUNCTION(a(), b()); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \
{ \
return FUNCTION(a(), b); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \
return FUNCTION(a, b()); \
}
//
// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
//
#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \
_GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \
{ \
return FUNCTION(a(), b(), c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
{ \
return FUNCTION(a(), b(), c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
{ \
return FUNCTION(a(), b, c); \
} \
_GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \
{ \
return FUNCTION(a, b(), c); \
}
}//namespace detail
}//namespace glm
namespace glm
{
namespace detail
{
_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
}
//
// Swizzles are distinct types from the unswizzled type. The below macros will
// provide template specializations for the swizzle types for the given functions
// so that the compiler does not have any ambiguity to choosing how to handle
// the function.
//
// The alternative is to use the operator()() when calling the function in order
// to explicitly convert the swizzled type to the unswizzled type.
//
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all);
//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross);
//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step);
//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
}
#define _GLM_SWIZZLE2_2_MEMBERS(T,P,E0,E1) \
struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; };
#define _GLM_SWIZZLE2_3_MEMBERS(T,P2,E0,E1) \
struct { glm::detail::swizzle<3,T,P2,0,0,0,-1> E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P2,0,0,1,-1> E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P2,0,1,0,-1> E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P2,0,1,1,-1> E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P2,1,0,0,-1> E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P2,1,0,1,-1> E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P2,1,1,0,-1> E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P2,1,1,1,-1> E1 ## E1 ## E1; };
#define _GLM_SWIZZLE2_4_MEMBERS(T,P2,E0,E1) \
struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; };
#define _GLM_SWIZZLE3_2_MEMBERS(T,P2,E0,E1,E2) \
struct { glm::detail::swizzle<2,T,P2,0,0,-1,-2> E0 ## E0; }; \
struct { glm::detail::swizzle<2,T,P2,0,1,-1,-2> E0 ## E1; }; \
struct { glm::detail::swizzle<2,T,P2,0,2,-1,-2> E0 ## E2; }; \
struct { glm::detail::swizzle<2,T,P2,1,0,-1,-2> E1 ## E0; }; \
struct { glm::detail::swizzle<2,T,P2,1,1,-1,-2> E1 ## E1; }; \
struct { glm::detail::swizzle<2,T,P2,1,2,-1,-2> E1 ## E2; }; \
struct { glm::detail::swizzle<2,T,P2,2,0,-1,-2> E2 ## E0; }; \
struct { glm::detail::swizzle<2,T,P2,2,1,-1,-2> E2 ## E1; }; \
struct { glm::detail::swizzle<2,T,P2,2,2,-1,-2> E2 ## E2; };
#define _GLM_SWIZZLE3_3_MEMBERS(T,P,E0,E1,E2) \
struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; };
#define _GLM_SWIZZLE3_4_MEMBERS(T,P2,E0,E1,E2) \
struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P2,2,2,2,2> E2 ## E2 ## E2 ## E2; };
#define _GLM_SWIZZLE4_2_MEMBERS(T,P,E0,E1,E2,E3) \
struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
struct { glm::detail::swizzle<2,T,P,0,2,-1,-2> E0 ## E2; }; \
struct { glm::detail::swizzle<2,T,P,0,3,-1,-2> E0 ## E3; }; \
struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; }; \
struct { glm::detail::swizzle<2,T,P,1,2,-1,-2> E1 ## E2; }; \
struct { glm::detail::swizzle<2,T,P,1,3,-1,-2> E1 ## E3; }; \
struct { glm::detail::swizzle<2,T,P,2,0,-1,-2> E2 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,2,1,-1,-2> E2 ## E1; }; \
struct { glm::detail::swizzle<2,T,P,2,2,-1,-2> E2 ## E2; }; \
struct { glm::detail::swizzle<2,T,P,2,3,-1,-2> E2 ## E3; }; \
struct { glm::detail::swizzle<2,T,P,3,0,-1,-2> E3 ## E0; }; \
struct { glm::detail::swizzle<2,T,P,3,1,-1,-2> E3 ## E1; }; \
struct { glm::detail::swizzle<2,T,P,3,2,-1,-2> E3 ## E2; }; \
struct { glm::detail::swizzle<2,T,P,3,3,-1,-2> E3 ## E3; };
#define _GLM_SWIZZLE4_3_MEMBERS(T,P,E0,E1,E2,E3) \
struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,0,3,-1> E0 ## E0 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,1,3,-1> E0 ## E1 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,2,3,-1> E0 ## E2 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,0,3,0,-1> E0 ## E3 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,0,3,1,-1> E0 ## E3 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,0,3,2,-1> E0 ## E3 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,0,3,3,-1> E0 ## E3 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,0,3,-1> E1 ## E0 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,1,3,-1> E1 ## E1 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,2,3,-1> E1 ## E2 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,1,3,0,-1> E1 ## E3 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,1,3,1,-1> E1 ## E3 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,1,3,2,-1> E1 ## E3 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,1,3,3,-1> E1 ## E3 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,0,3,-1> E2 ## E0 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,1,3,-1> E2 ## E1 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,2,3,-1> E2 ## E2 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,2,3,0,-1> E2 ## E3 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,2,3,1,-1> E2 ## E3 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,2,3,2,-1> E2 ## E3 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,2,3,3,-1> E2 ## E3 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,3,0,0,-1> E3 ## E0 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,3,0,1,-1> E3 ## E0 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,3,0,2,-1> E3 ## E0 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,3,0,3,-1> E3 ## E0 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,3,1,0,-1> E3 ## E1 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,3,1,1,-1> E3 ## E1 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,3,1,2,-1> E3 ## E1 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,3,1,3,-1> E3 ## E1 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,3,2,0,-1> E3 ## E2 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,3,2,1,-1> E3 ## E2 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,3,2,2,-1> E3 ## E2 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,3,2,3,-1> E3 ## E2 ## E3; }; \
struct { glm::detail::swizzle<3,T,P,3,3,0,-1> E3 ## E3 ## E0; }; \
struct { glm::detail::swizzle<3,T,P,3,3,1,-1> E3 ## E3 ## E1; }; \
struct { glm::detail::swizzle<3,T,P,3,3,2,-1> E3 ## E3 ## E2; }; \
struct { glm::detail::swizzle<3,T,P,3,3,3,-1> E3 ## E3 ## E3; };
#define _GLM_SWIZZLE4_4_MEMBERS(T,P,E0,E1,E2,E3) \
struct { glm::detail::swizzle<4,T,P,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
struct { glm::detail::swizzle<4,T,P,3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
struct { glm::detail::swizzle<4,T,P,3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
struct { glm::detail::swizzle<4,T,P,3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
struct { glm::detail::swizzle<4,T,P,3,3,3,3> E3 ## E3 ## E3 ## E3; };
#endif//glm_core_swizzle

787
Glm/core/_swizzle_func.hpp

@ -0,0 +1,787 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_swizzle_func.hpp
/// @date 2011-10-16 / 2011-10-16
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_swizzle_func
#define glm_core_swizzle_func
#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
SWIZZLED_TYPE<TMPL_TYPE> A ## B() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
}
#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
}
#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C ## D() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
}
#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
}
#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
}
#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
template <typename TMPL_TYPE> \
SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C ## D() CONST \
{ \
return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
}
#define GLM_MUTABLE
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, q)
//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
#endif//glm_core_swizzle_func

159
Glm/core/_vectorize.hpp

@ -0,0 +1,159 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/_vectorize.hpp
/// @date 2011-10-14 / 2011-10-14
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#define VECTORIZE2_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func( \
detail::tvec2<T> const & v) \
{ \
return detail::tvec2<T>( \
func(v.x), \
func(v.y)); \
}
#define VECTORIZE3_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func( \
detail::tvec3<T> const & v) \
{ \
return detail::tvec3<T>( \
func(v.x), \
func(v.y), \
func(v.z)); \
}
#define VECTORIZE4_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func( \
detail::tvec4<T> const & v) \
{ \
return detail::tvec4<T>( \
func(v.x), \
func(v.y), \
func(v.z), \
func(v.w)); \
}
#define VECTORIZE_VEC(func) \
VECTORIZE2_VEC(func) \
VECTORIZE3_VEC(func) \
VECTORIZE4_VEC(func)
#define VECTORIZE2_VEC_SCA(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func \
( \
detail::tvec2<T> const & x, \
typename detail::tvec2<T>::value_type const & y \
) \
{ \
return detail::tvec2<T>( \
func(x.x, y), \
func(x.y, y)); \
}
#define VECTORIZE3_VEC_SCA(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func \
( \
detail::tvec3<T> const & x, \
typename detail::tvec3<T>::value_type const & y \
) \
{ \
return detail::tvec3<T>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y)); \
}
#define VECTORIZE4_VEC_SCA(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func \
( \
detail::tvec4<T> const & x, \
typename detail::tvec4<T>::value_type const & y \
) \
{ \
return detail::tvec4<T>( \
func(x.x, y), \
func(x.y, y), \
func(x.z, y), \
func(x.w, y)); \
}
#define VECTORIZE_VEC_SCA(func) \
VECTORIZE2_VEC_SCA(func) \
VECTORIZE3_VEC_SCA(func) \
VECTORIZE4_VEC_SCA(func)
#define VECTORIZE2_VEC_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func \
( \
detail::tvec2<T> const & x, \
detail::tvec2<T> const & y \
) \
{ \
return detail::tvec2<T>( \
func(x.x, y.x), \
func(x.y, y.y)); \
}
#define VECTORIZE3_VEC_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func \
( \
detail::tvec3<T> const & x, \
detail::tvec3<T> const & y \
) \
{ \
return detail::tvec3<T>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z)); \
}
#define VECTORIZE4_VEC_VEC(func) \
template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func \
( \
detail::tvec4<T> const & x, \
detail::tvec4<T> const & y \
) \
{ \
return detail::tvec4<T>( \
func(x.x, y.x), \
func(x.y, y.y), \
func(x.z, y.z), \
func(x.w, y.w)); \
}
#define VECTORIZE_VEC_VEC(func) \
VECTORIZE2_VEC_VEC(func) \
VECTORIZE3_VEC_VEC(func) \
VECTORIZE4_VEC_VEC(func)

35
Glm/core/dummy.cpp

@ -0,0 +1,35 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/dummy.cpp
/// @date 2011-01-19 / 2011-06-15
/// @author Christophe Riccio
///
/// GLM is a header only library. There is nothing to compile.
/// dummy.cpp exist only a wordaround for CMake file.
///////////////////////////////////////////////////////////////////////////////////
#define GLM_MESSAGES
#include "../glm.hpp"
//#error "GLM is a header only library"

430
Glm/core/func_common.hpp

@ -0,0 +1,430 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_common.hpp
/// @date 2008-03-08 / 2010-01-26
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @defgroup core_func_common Common functions
/// @ingroup core
///
/// These all operate component-wise. The description is per component.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_func_common
#define GLM_CORE_func_common GLM_VERSION
#include "_fixes.hpp"
namespace glm
{
/// @addtogroup core_func_common
/// @{
/// Returns x if x >= 0; otherwise, it returns -x.
///
/// @tparam genType floating-point or signed integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType abs(genType const & x);
/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
///
/// @tparam genType Floating-point or signed integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType sign(genType const & x);
/// Returns a value equal to the nearest integer that is less then or equal to x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType floor(genType const & x);
/// Returns a value equal to the nearest integer to x
/// whose absolute value is not larger than the absolute value of x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType trunc(genType const & x);
/// Returns a value equal to the nearest integer to x.
/// The fraction 0.5 will round in a direction chosen by the
/// implementation, presumably the direction that is fastest.
/// This includes the possibility that round(x) returns the
/// same value as roundEven(x) for all values of x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType round(genType const & x);
/// Returns a value equal to the nearest integer to x.
/// A fractional part of 0.5 will round toward the nearest even
/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
template <typename genType>
GLM_FUNC_DECL genType roundEven(genType const & x);
/// Returns a value equal to the nearest integer
/// that is greater than or equal to x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType ceil(genType const & x);
/// Return x - floor(x).
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType fract(genType const & x);
/// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType mod(
genType const & x,
genType const & y);
/// Modulus. Returns x - y * floor(x / y)
/// for each component in x using the floating point value y.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType mod(
genType const & x,
typename genType::value_type const & y);
/// Returns the fractional part of x and sets i to the integer
/// part (as a whole number floating point value). Both the
/// return value and the output parameter will have the same
/// sign as x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType modf(
genType const & x,
genType & i);
/// Returns y if y < x; otherwise, it returns x.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType min(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType min(
genType const & x,
typename genType::value_type const & y);
/// Returns y if x < y; otherwise, it returns x.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType max(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType max(
genType const & x,
typename genType::value_type const & y);
/// Returns min(max(x, minVal), maxVal) for each component in x
/// using the floating-point values minVal and maxVal.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType clamp(
genType const & x,
genType const & minVal,
genType const & maxVal);
template <typename genType>
GLM_FUNC_DECL genType clamp(
genType const & x,
typename genType::value_type const & minVal,
typename genType::value_type const & maxVal);
/// If genTypeU is a floating scalar or vector:
/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
/// x and y using the floating-point value a.
/// The value for a is not restricted to the range [0, 1].
///
/// If genTypeU is a boolean scalar or vector:
/// Selects which vector each returned component comes
/// from. For a component of <a> that is false, the
/// corresponding component of x is returned. For a
/// component of a that is true, the corresponding
/// component of y is returned. Components of x and y that
/// are not selected are allowed to be invalid floating point
/// values and will have no effect on the results. Thus, this
/// provides different functionality than
/// genType mix(genType x, genType y, genType(a))
/// where a is a Boolean vector.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @param[in] x Value to interpolate.
/// @param[in] y Value to interpolate.
/// @param[in] a Interpolant.
///
/// @tparam genTypeT Floating point scalar or vector.
/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
///
/// @code
/// #include <glm/glm.hpp>
/// ...
/// float a;
/// bool b;
/// glm::dvec3 e;
/// glm::dvec3 f;
/// glm::vec4 g;
/// glm::vec4 h;
/// ...
/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors.
/// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
/// @endcode
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
//! Returns 0.0 if x < edge, otherwise it returns 1.0.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType step(
genType const & edge,
genType const & x);
template <typename genType>
GLM_FUNC_DECL genType step(
typename genType::value_type const & edge,
genType const & x);
/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
/// performs smooth Hermite interpolation between 0 and 1
/// when edge0 < x < edge1. This is useful in cases where
/// you would want a threshold function with a smooth
/// transition. This is equivalent to:
/// genType t;
/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
/// return t * t * (3 - 2 * t);
/// Results are undefined if edge0 >= edge1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType smoothstep(
genType const & edge0,
genType const & edge1,
genType const & x);
template <typename genType>
GLM_FUNC_DECL genType smoothstep(
typename genType::value_type const & edge0,
typename genType::value_type const & edge1,
genType const & x);
/// Returns true if x holds a NaN (not a number)
/// representation in the underlying implementation's set of
/// floating point representations. Returns false otherwise,
/// including for implementations with no NaN
/// representations.
///
/// /!\ When using compiler fast math, this function may fail.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
/// Returns true if x holds a positive infinity or negative
/// infinity representation in the underlying implementation's
/// set of floating point representations. Returns false
/// otherwise, including for implementations with no infinity
/// representations.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
/// Returns a signed integer value representing
/// the encoding of a floating-point value. The floatingpoint
/// value's bit-level representation is preserved.
///
/// @tparam genType Single-precision floating-point scalar or vector types.
/// @tparam genIType Signed integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
GLM_FUNC_DECL genIType floatBitsToInt(genType const & value);
/// Returns a unsigned integer value representing
/// the encoding of a floating-point value. The floatingpoint
/// value's bit-level representation is preserved.
///
/// @tparam genType Single-precision floating-point scalar or vector types.
/// @tparam genUType Unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genUType>
GLM_FUNC_DECL genUType floatBitsToUint(genType const & value);
/// Returns a floating-point value corresponding to a signed
/// integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @tparam genType Single-precision floating-point scalar or vector types.
/// @tparam genIType Signed integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @todo Clarify this declaration, we don't need to actually specify the return type
template <typename genType, typename genIType>
GLM_FUNC_DECL genType intBitsToFloat(genIType const & value);
/// Returns a floating-point value corresponding to a
/// unsigned integer encoding of a floating-point value.
/// If an inf or NaN is passed in, it will not signal, and the
/// resulting floating point value is unspecified. Otherwise,
/// the bit-level representation is preserved.
///
/// @tparam genType Single-precision floating-point scalar or vector types.
/// @tparam genUType Unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
///
/// @todo Clarify this declaration, we don't need to actually specify the return type
template <typename genType, typename genUType>
GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value);
/// Computes and returns a * b + c.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
/// Splits x into a floating-point significand in the range
/// [0.5, 1.0) and an integral exponent of two, such that:
/// x = significand * exp(2, exponent)
///
/// The significand is returned by the function and the
/// exponent is returned in the parameter exp. For a
/// floating-point value of zero, the significant and exponent
/// are both zero. For a floating-point value that is an
/// infinity or is not a number, the results are undefined.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
/// Builds a floating-point number from x and the
/// corresponding integral exponent of two in exp, returning:
/// significand * exp(2, exponent)
///
/// If this product is too large to be represented in the
/// floating-point type, the result is undefined.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>;
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType, typename genIType>
GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
/// @}
}//namespace glm
#include "func_common.inl"
#endif//GLM_CORE_func_common

1226
Glm/core/func_common.inl
File diff suppressed because it is too large
View File

123
Glm/core/func_exponential.hpp

@ -0,0 +1,123 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_exponential.hpp
/// @date 2008-08-08 / 2011-06-14
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
///
/// @defgroup core_func_exponential Exponential functions
/// @ingroup core
///
/// These all operate component-wise. The description is per component.
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_func_exponential
#define glm_core_func_exponential GLM_VERSION
namespace glm
{
/// @addtogroup core_func_exponential
/// @{
/// Returns 'base' raised to the power 'exponent'.
///
/// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
/// @param exponent Floating point value representing the 'exponent'.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
/// Returns the natural exponentiation of x, i.e., e^x.
///
/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType exp(genType const & x);
/// Returns the natural logarithm of x, i.e.,
/// returns the value y which satisfies the equation x = e^y.
/// Results are undefined if x <= 0.
///
/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType log(genType const & x);
/// Returns 2 raised to the x power.
///
/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType exp2(genType const & x);
/// Returns the base 2 log of x, i.e., returns the value y,
/// which satisfies the equation x = 2 ^ y.
///
/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType log2(genType const & x);
/// Returns the positive square root of x.
///
/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType sqrt(genType const & x);
/// Returns the reciprocal of the positive square root of x.
///
/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template <typename genType>
GLM_FUNC_DECL genType inversesqrt(genType const & x);
/// @}
}//namespace glm
#include "func_exponential.inl"
#endif//glm_core_func_exponential

156
Glm/core/func_exponential.inl

@ -0,0 +1,156 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_exponential.inl
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// pow
template <typename genType>
GLM_FUNC_QUALIFIER genType pow
(
genType const & x,
genType const & y
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'pow' only accept floating-point input");
return genType(::std::pow(x, y));
}
VECTORIZE_VEC_VEC(pow)
// exp
template <typename genType>
GLM_FUNC_QUALIFIER genType exp
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp' only accept floating-point input");
return genType(::std::exp(x));
}
VECTORIZE_VEC(exp)
// log
template <typename genType>
GLM_FUNC_QUALIFIER genType log
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log' only accept floating-point input");
return genType(::std::log(x));
}
VECTORIZE_VEC(log)
//exp2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType exp2
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp2' only accept floating-point input");
return genType(::std::exp(genType(0.69314718055994530941723212145818) * x));
}
VECTORIZE_VEC(exp2)
namespace _detail
{
template <int _PATH = detail::float_or_int_value::GLM_ERROR>
struct _compute_log2
{
template <typename T>
T operator() (T const & Value) const;
/*
{
GLM_STATIC_ASSERT(0, "'log2' parameter has an invalid template parameter type. GLM core features only supports floating-point types, include <glm/gtx/integer.hpp> for integer types support. Others types are not supported.");
return Value;
}
*/
};
template <>
struct _compute_log2<detail::float_or_int_value::GLM_FLOAT>
{
template <typename T>
T operator() (T const & Value) const
{
return T(::std::log(Value)) / T(0.69314718055994530941723212145818);
}
};
}//namespace _detail
// log2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType log2
(
genType const & x
)
{
assert(x > genType(0)); // log2 is only defined on the range (0, inf]
return _detail::_compute_log2<detail::float_or_int_trait<genType>::ID>()(x);
}
VECTORIZE_VEC(log2)
// sqrt
template <typename genType>
GLM_FUNC_QUALIFIER genType sqrt
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sqrt' only accept floating-point input");
return genType(::std::sqrt(x));
}
VECTORIZE_VEC(sqrt)
template <typename genType>
GLM_FUNC_QUALIFIER genType inversesqrt
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
assert(x > genType(0));
return genType(1) / ::std::sqrt(x);
}
VECTORIZE_VEC(inversesqrt)
}//namespace glm

138
Glm/core/func_geometric.hpp

@ -0,0 +1,138 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_geometric.hpp
/// @date 2008-08-03 / 2011-06-14
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
///
/// @defgroup core_func_geometric Geometric functions
/// @ingroup core
///
/// These operate on vectors as vectors, not component-wise.
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_func_geometric
#define glm_core_func_geometric GLM_VERSION
namespace glm
{
/// @addtogroup core_func_geometric
/// @{
/// Returns the length of x, i.e., sqrt(x * x).
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::value_type length(
genType const & x);
/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::value_type distance(
genType const & p0,
genType const & p1);
/// Returns the dot product of x and y, i.e., result = x * y.
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::value_type dot(
genType const & x,
genType const & y);
/// Returns the cross product of x and y.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename valType>
GLM_FUNC_DECL detail::tvec3<valType> cross(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y);
/// Returns a vector in the same direction as x but with length of 1.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL genType normalize(
genType const & x);
/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL genType faceforward(
genType const & N,
genType const & I,
genType const & Nref);
/// For the incident vector I and surface orientation N,
/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL genType reflect(
genType const & I,
genType const & N);
/// For the incident vector I and surface normal N,
/// and the ratio of indices of refraction eta,
/// return the refraction vector.
///
/// @tparam genType Floating-point vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template <typename genType>
GLM_FUNC_DECL genType refract(
genType const & I,
genType const & N,
typename genType::value_type const & eta);
/// @}
}//namespace glm
#include "func_geometric.inl"
#endif//glm_core_func_geometric

321
Glm/core/func_geometric.inl

@ -0,0 +1,321 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_geometric.inl
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// length
template <typename genType>
GLM_FUNC_QUALIFIER genType length
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'length' only accept floating-point inputs");
genType sqr = x * x;
return sqrt(sqr);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type length
(
detail::tvec2<T> const & v
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
return sqrt(sqr);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type length
(
detail::tvec3<T> const & v
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
return sqrt(sqr);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type length
(
detail::tvec4<T> const & v
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
return sqrt(sqr);
}
// distance
template <typename genType>
GLM_FUNC_QUALIFIER genType distance
(
genType const & p0,
genType const & p1
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'distance' only accept floating-point inputs");
return length(p1 - p0);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type distance
(
detail::tvec2<T> const & p0,
detail::tvec2<T> const & p1
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
return length(p1 - p0);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type distance
(
detail::tvec3<T> const & p0,
detail::tvec3<T> const & p1
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
return length(p1 - p0);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type distance
(
detail::tvec4<T> const & p0,
detail::tvec4<T> const & p1
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
return length(p1 - p0);
}
// dot
template <typename genType>
GLM_FUNC_QUALIFIER genType dot
(
genType const & x,
genType const & y
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");
return x * y;
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type dot
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
return x.x * y.x + x.y * y.y;
}
template <typename T>
GLM_FUNC_QUALIFIER T dot
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
return x.x * y.x + x.y * y.y + x.z * y.z;
}
/* // SSE3
GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
{
float Result;
__asm
{
mov esi, x
mov edi, y
movaps xmm0, [esi]
mulps xmm0, [edi]
haddps( _xmm0, _xmm0 )
haddps( _xmm0, _xmm0 )
movss Result, xmm0
}
return Result;
}
*/
template <typename T>
GLM_FUNC_QUALIFIER T dot
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
}
// cross
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> cross
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'cross' only accept floating-point inputs");
return detail::tvec3<T>(
x.y * y.z - y.y * x.z,
x.z * y.x - y.z * x.x,
x.x * y.y - y.x * x.y);
}
// normalize
template <typename genType>
GLM_FUNC_QUALIFIER genType normalize
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'normalize' only accept floating-point inputs");
return x < genType(0) ? genType(-1) : genType(1);
}
// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> normalize
(
detail::tvec2<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
return x * inversesqrt(sqr);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> normalize
(
detail::tvec3<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
return x * inversesqrt(sqr);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> normalize
(
detail::tvec4<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
return x * inversesqrt(sqr);
}
// faceforward
template <typename genType>
GLM_FUNC_QUALIFIER genType faceforward
(
genType const & N,
genType const & I,
genType const & Nref
)
{
return dot(Nref, I) < 0 ? N : -N;
}
// reflect
template <typename genType>
GLM_FUNC_QUALIFIER genType reflect
(
genType const & I,
genType const & N
)
{
return I - N * dot(N, I) * genType(2);
}
// refract
template <typename genType>
GLM_FUNC_QUALIFIER genType refract
(
genType const & I,
genType const & N,
genType const & eta
)
{
//It could be a vector
//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
genType dotValue = dot(N, I);
genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
if(k < genType(0))
return genType(0);
else
return eta * I - (eta * dotValue + sqrt(k)) * N;
}
template <typename genType>
GLM_FUNC_QUALIFIER genType refract
(
genType const & I,
genType const & N,
typename genType::value_type const & eta
)
{
//It could be a vector
//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
typename genType::value_type dotValue = dot(N, I);
typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
if(k < typename genType::value_type(0))
return genType(0);
else
return eta * I - (eta * dotValue + sqrt(k)) * N;
}
}//namespace glm

201
Glm/core/func_integer.hpp

@ -0,0 +1,201 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_integer.hpp
/// @date 2010-03-17 / 2011-06-18
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
///
/// @defgroup core_func_integer Integer functions
/// @ingroup core
///
/// These all operate component-wise. The description is per component.
/// The notation [a, b] means the set of bits from bit-number a through bit-number
/// b, inclusive. The lowest-order bit is bit 0.
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_func_integer
#define glm_core_func_integer GLM_VERSION
namespace glm
{
/// @addtogroup core_func_integer
/// @{
/// Adds 32-bit unsigned integer x and y, returning the sum
/// modulo pow(2, 32). The value carry is set to 0 if the sum was
/// less than pow(2, 32), or to 1 otherwise.
///
/// @tparam genUType Unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
GLM_FUNC_DECL genUType uaddCarry(
genUType const & x,
genUType const & y,
genUType & carry);
/// Subtracts the 32-bit unsigned integer y from x, returning
/// the difference if non-negative, or pow(2, 32) plus the difference
/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
///
/// @tparam genUType Unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
GLM_FUNC_DECL genUType usubBorrow(
genUType const & x,
genUType const & y,
genUType & borrow);
/// Multiplies 32-bit integers x and y, producing a 64-bit
/// result. The 32 least-significant bits are returned in lsb.
/// The 32 most-significant bits are returned in msb.
///
/// @tparam genUType Unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genUType>
GLM_FUNC_DECL void umulExtended(
genUType const & x,
genUType const & y,
genUType & msb,
genUType & lsb);
/// Multiplies 32-bit integers x and y, producing a 64-bit
/// result. The 32 least-significant bits are returned in lsb.
/// The 32 most-significant bits are returned in msb.
///
/// @tparam genIType Signed integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIType>
GLM_FUNC_DECL void imulExtended(
genIType const & x,
genIType const & y,
genIType & msb,
genIType & lsb);
/// Extracts bits [offset, offset + bits - 1] from value,
/// returning them in the least significant bits of the result.
/// For unsigned data types, the most significant bits of the
/// result will be set to zero. For signed data types, the
/// most significant bits will be set to the value of bit offset + base - 1.
///
/// If bits is zero, the result will be zero. The result will be
/// undefined if offset or bits is negative, or if the sum of
/// offset and bits is greater than the number of bits used
/// to store the operand.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldExtract(
genIUType const & Value,
int const & Offset,
int const & Bits);
/// Returns the insertion the bits least-significant bits of insert into base.
///
/// The result will have bits [offset, offset + bits - 1] taken
/// from bits [0, bits - 1] of insert, and all other bits taken
/// directly from the corresponding bits of base. If bits is
/// zero, the result will simply be base. The result will be
/// undefined if offset or bits is negative, or if the sum of
/// offset and bits is greater than the number of bits used to
/// store the operand.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldInsert(
genIUType const & Base,
genIUType const & Insert,
int const & Offset,
int const & Bits);
/// Returns the reversal of the bits of value.
/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value,
/// where bits is the total number of bits used to represent value.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
/// Returns the number of bits set to 1 in the binary representation of value.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
/// Returns the bit number of the least significant bit set to
/// 1 in the binary representation of value.
/// If value is zero, -1 will be returned.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
/// Returns the bit number of the most significant bit in the binary representation of value.
/// For positive integers, the result will be the bit number of the most significant bit set to 1.
/// For negative integers, the result will be the bit number of the most significant
/// bit set to 0. For a value of zero or negative one, -1 will be returned.
///
/// @tparam genIUType Signed or unsigned integer scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
///
/// @todo Clarify the declaration to specify that scalars are suported.
template <typename T, template <typename> class genIUType>
GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
/// @}
}//namespace glm
#include "func_integer.inl"
#endif//glm_core_func_integer

648
Glm/core/func_integer.inl

@ -0,0 +1,648 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_integer.inl
/// @date 2010-03-17 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#if(GLM_ARCH != GLM_ARCH_PURE)
#if(GLM_COMPILER & GLM_COMPILER_VC)
# include <intrin.h>
# pragma intrinsic(_BitScanReverse)
#endif//(GLM_COMPILER & GLM_COMPILER_VC)
#endif//(GLM_ARCH != GLM_ARCH_PURE)
namespace glm
{
// uaddCarry
template <typename genUType>
GLM_FUNC_QUALIFIER genUType uaddCarry
(
genUType const & x,
genUType const & y,
genUType & Carry
)
{
detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y,
detail::tvec2<T> & Carry
)
{
return detail::tvec2<T>(
uaddCarry(x[0], y[0], Carry[0]),
uaddCarry(x[1], y[1], Carry[1]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
detail::tvec3<T> & Carry
)
{
return detail::tvec3<T>(
uaddCarry(x[0], y[0], Carry[0]),
uaddCarry(x[1], y[1], Carry[1]),
uaddCarry(x[2], y[2], Carry[2]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y,
detail::tvec4<T> & Carry
)
{
return detail::tvec4<T>(
uaddCarry(x[0], y[0], Carry[0]),
uaddCarry(x[1], y[1], Carry[1]),
uaddCarry(x[2], y[2], Carry[2]),
uaddCarry(x[3], y[3], Carry[3]));
}
// usubBorrow
template <typename genUType>
GLM_FUNC_QUALIFIER genUType usubBorrow
(
genUType const & x,
genUType const & y,
genUType & Borrow
)
{
Borrow = x >= y ? 0 : 1;
if(x > y)
return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
else
return genUType((detail::highp_int_t(1) << detail::highp_int_t(32)) + detail::highp_int_t(x) - detail::highp_int_t(y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y,
detail::tvec2<T> & Borrow
)
{
return detail::tvec2<T>(
usubBorrow(x[0], y[0], Borrow[0]),
usubBorrow(x[1], y[1], Borrow[1]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
detail::tvec3<T> & Borrow
)
{
return detail::tvec3<T>(
usubBorrow(x[0], y[0], Borrow[0]),
usubBorrow(x[1], y[1], Borrow[1]),
usubBorrow(x[2], y[2], Borrow[2]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y,
detail::tvec4<T> & Borrow
)
{
return detail::tvec4<T>(
usubBorrow(x[0], y[0], Borrow[0]),
usubBorrow(x[1], y[1], Borrow[1]),
usubBorrow(x[2], y[2], Borrow[2]),
usubBorrow(x[3], y[3], Borrow[3]));
}
// umulExtended
template <typename genUType>
GLM_FUNC_QUALIFIER void umulExtended
(
genUType const & x,
genUType const & y,
genUType & msb,
genUType & lsb
)
{
detail::highp_uint_t ValueX64 = x;
detail::highp_uint_t ValueY64 = y;
detail::highp_uint_t Value64 = ValueX64 * ValueY64;
msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y,
detail::tvec2<T> & msb,
detail::tvec2<T> & lsb
)
{
return detail::tvec2<T>(
umulExtended(x[0], y[0], msb, lsb),
umulExtended(x[1], y[1], msb, lsb));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
detail::tvec3<T> & msb,
detail::tvec3<T> & lsb
)
{
return detail::tvec3<T>(
umulExtended(x[0], y[0], msb, lsb),
umulExtended(x[1], y[1], msb, lsb),
umulExtended(x[2], y[2], msb, lsb));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y,
detail::tvec4<T> & msb,
detail::tvec4<T> & lsb
)
{
return detail::tvec4<T>(
umulExtended(x[0], y[0], msb, lsb),
umulExtended(x[1], y[1], msb, lsb),
umulExtended(x[2], y[2], msb, lsb),
umulExtended(x[3], y[3], msb, lsb));
}
// imulExtended
template <typename genIType>
GLM_FUNC_QUALIFIER void imulExtended
(
genIType const & x,
genIType const & y,
genIType & msb,
genIType & lsb
)
{
detail::highp_int_t ValueX64 = x;
detail::highp_int_t ValueY64 = y;
detail::highp_int_t Value64 = ValueX64 * ValueY64;
msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y,
detail::tvec2<T> & msb,
detail::tvec2<T> & lsb
)
{
return detail::tvec2<T>(
imulExtended(x[0], y[0], msb, lsb),
imulExtended(x[1], y[1], msb, lsb));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
detail::tvec3<T> & msb,
detail::tvec3<T> & lsb
)
{
return detail::tvec3<T>(
imulExtended(x[0], y[0], msb, lsb),
imulExtended(x[1], y[1], msb, lsb),
imulExtended(x[2], y[2], msb, lsb));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y,
detail::tvec4<T> & msb,
detail::tvec4<T> & lsb
)
{
return detail::tvec4<T>(
imulExtended(x[0], y[0], msb, lsb),
imulExtended(x[1], y[1], msb, lsb),
imulExtended(x[2], y[2], msb, lsb),
imulExtended(x[3], y[3], msb, lsb));
}
// bitfieldExtract
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldExtract
(
genIUType const & Value,
int const & Offset,
int const & Bits
)
{
int GenSize = int(sizeof(genIUType)) << int(3);
assert(Offset + Bits <= GenSize);
genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
return ShiftBack;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
(
detail::tvec2<T> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec2<T>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
(
detail::tvec3<T> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec3<T>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits),
bitfieldExtract(Value[2], Offset, Bits));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
(
detail::tvec4<T> const & Value,
int const & Offset,
int const & Bits
)
{
return detail::tvec4<T>(
bitfieldExtract(Value[0], Offset, Bits),
bitfieldExtract(Value[1], Offset, Bits),
bitfieldExtract(Value[2], Offset, Bits),
bitfieldExtract(Value[3], Offset, Bits));
}
// bitfieldInsert
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldInsert
(
genIUType const & Base,
genIUType const & Insert,
int const & Offset,
int const & Bits
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
assert(Offset + Bits <= sizeof(genIUType));
if(Bits == 0)
return Base;
genIUType Mask = 0;
for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
Mask |= (1 << Bit);
return (Base & ~Mask) | (Insert & Mask);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
(
detail::tvec2<T> const & Base,
detail::tvec2<T> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec2<T>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
(
detail::tvec3<T> const & Base,
detail::tvec3<T> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec3<T>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits),
bitfieldInsert(Base[2], Insert[2], Offset, Bits));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
(
detail::tvec4<T> const & Base,
detail::tvec4<T> const & Insert,
int const & Offset,
int const & Bits
)
{
return detail::tvec4<T>(
bitfieldInsert(Base[0], Insert[0], Offset, Bits),
bitfieldInsert(Base[1], Insert[1], Offset, Bits),
bitfieldInsert(Base[2], Insert[2], Offset, Bits),
bitfieldInsert(Base[3], Insert[3], Offset, Bits));
}
// bitfieldReverse
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
genIUType Out = 0;
std::size_t BitSize = sizeof(genIUType) * 8;
for(std::size_t i = 0; i < BitSize; ++i)
if(Value & (genIUType(1) << i))
Out |= genIUType(1) << (BitSize - 1 - i);
return Out;
}
VECTORIZE_VEC(bitfieldReverse)
// bitCount
template <typename genIUType>
GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
int Count = 0;
for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
{
if(Value & (1 << i))
++Count;
}
return Count;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
(
detail::tvec2<T> const & value
)
{
return detail::tvec2<int>(
bitCount(value[0]),
bitCount(value[1]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
(
detail::tvec3<T> const & value
)
{
return detail::tvec3<int>(
bitCount(value[0]),
bitCount(value[1]),
bitCount(value[2]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
(
detail::tvec4<T> const & value
)
{
return detail::tvec4<int>(
bitCount(value[0]),
bitCount(value[1]),
bitCount(value[2]),
bitCount(value[3]));
}
// findLSB
template <typename genIUType>
GLM_FUNC_QUALIFIER int findLSB
(
genIUType const & Value
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
if(Value == 0)
return -1;
genIUType Bit;
for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
return Bit;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
(
detail::tvec2<T> const & value
)
{
return detail::tvec2<int>(
findLSB(value[0]),
findLSB(value[1]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
(
detail::tvec3<T> const & value
)
{
return detail::tvec3<int>(
findLSB(value[0]),
findLSB(value[1]),
findLSB(value[2]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
(
detail::tvec4<T> const & value
)
{
return detail::tvec4<int>(
findLSB(value[0]),
findLSB(value[1]),
findLSB(value[2]),
findLSB(value[3]));
}
// findMSB
#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
template <typename genIUType>
GLM_FUNC_QUALIFIER int findMSB
(
genIUType const & Value
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == 0)
return -1;
unsigned long Result(0);
_BitScanReverse(&Result, Value);
return int(Result);
}
/*
// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
template <typename genIUType>
GLM_FUNC_QUALIFIER int findMSB
(
genIUType const & Value
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == 0)
return -1;
// clz returns the number or trailing 0-bits; see
// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
//
// NoteBecause __builtin_clz only works for unsigned ints, this
// implementation will not work for 64-bit integers.
//
return 31 - __builtin_clzl(Value);
}
*/
#else
/* SSE implementation idea
__m128i const Zero = _mm_set_epi32( 0, 0, 0, 0);
__m128i const One = _mm_set_epi32( 1, 1, 1, 1);
__m128i Bit = _mm_set_epi32(-1, -1, -1, -1);
__m128i Tmp = _mm_set_epi32(Value, Value, Value, Value);
__m128i Mmi = Zero;
for(int i = 0; i < 32; ++i)
{
__m128i Shilt = _mm_and_si128(_mm_cmpgt_epi32(Tmp, One), One);
Tmp = _mm_srai_epi32(Tmp, One);
Bit = _mm_add_epi32(Bit, _mm_and_si128(Shilt, i));
Mmi = _mm_and_si128(Mmi, One);
}
return Bit;
*/
template <typename genIUType>
GLM_FUNC_QUALIFIER int findMSB
(
genIUType const & Value
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == genIUType(0) || Value == genIUType(-1))
return -1;
else if(Value > 0)
{
genIUType Bit = genIUType(-1);
for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
return Bit;
}
else //if(Value < 0)
{
int const BitCount(sizeof(genIUType) * 8);
int MostSignificantBit(-1);
for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
assert(MostSignificantBit >= 0);
return MostSignificantBit;
}
}
#endif//(GLM_COMPILER)
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
(
detail::tvec2<T> const & value
)
{
return detail::tvec2<int>(
findMSB(value[0]),
findMSB(value[1]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
(
detail::tvec3<T> const & value
)
{
return detail::tvec3<int>(
findMSB(value[0]),
findMSB(value[1]),
findMSB(value[2]));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
(
detail::tvec4<T> const & value
)
{
return detail::tvec4<int>(
findMSB(value[0]),
findMSB(value[1]),
findMSB(value[2]),
findMSB(value[3]));
}
}//namespace glm

150
Glm/core/func_matrix.hpp

@ -0,0 +1,150 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_matrix.hpp
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
///
/// @defgroup core_func_matrix Matrix functions
/// @ingroup core
///
/// For each of the following built-in matrix functions, there is both a
/// single-precision floating point version, where all arguments and return values
/// are single precision, and a double-precision floating version, where all
/// arguments and return values are double precision. Only the single-precision
/// floating point version is shown.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_func_matrix
#define GLM_CORE_func_matrix GLM_VERSION
namespace glm
{
/// @addtogroup core_func_matrix
/// @{
/// Multiply matrix x by matrix y component-wise, i.e.,
/// result[i][j] is the scalar product of x[i][j] and y[i][j].
///
/// @tparam matType Floating-point matrix types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType>
GLM_FUNC_DECL matType matrixCompMult(
matType const & x,
matType const & y);
/// Treats the first parameter c as a column vector
/// and the second parameter r as a row vector
/// and does a linear algebraic matrix multiply c * r.
///
/// @tparam matType Floating-point matrix types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
///
/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
template <typename vecType, typename matType>
GLM_FUNC_DECL matType outerProduct(
vecType const & c,
vecType const & r);
/// Returns the transposed matrix of x
///
/// @tparam matType Floating-point matrix types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename matType>
GLM_FUNC_DECL typename matType::transpose_type transpose(
matType const & x);
/// Return the determinant of a mat2 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL typename detail::tmat2x2<valType>::value_type determinant(
detail::tmat2x2<valType> const & m);
/// Return the determinant of a mat3 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL typename detail::tmat3x3<valType>::value_type determinant(
detail::tmat3x3<valType> const & m);
/// Return the determinant of a mat4 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL typename detail::tmat4x4<valType>::value_type determinant(
detail::tmat4x4<valType> const & m);
/// Return the inverse of a mat2 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL detail::tmat2x2<valType> inverse(
detail::tmat2x2<valType> const & m);
/// Return the inverse of a mat3 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL detail::tmat3x3<valType> inverse(
detail::tmat3x3<valType> const & m);
/// Return the inverse of a mat4 matrix.
///
/// @tparam valType Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template <typename valType>
GLM_FUNC_DECL detail::tmat4x4<valType> inverse(
detail::tmat4x4<valType> const & m);
/// @}
}//namespace glm
#include "func_matrix.inl"
#endif//GLM_CORE_func_matrix

582
Glm/core/func_matrix.inl

@ -0,0 +1,582 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_matrix.inl
/// @date 2008-03-08 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// matrixCompMult
template <typename matType>
GLM_FUNC_QUALIFIER matType matrixCompMult
(
matType const & x,
matType const & y
)
{
GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float, "'matrixCompMult' only accept floating-point inputs");
matType result(matType::null);
for(typename matType::size_type i = 0; i < matType::row_size(); ++i)
result[i] = x[i] * y[i];
return result;
}
// outerProduct
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
(
detail::tvec2<T> const & c,
detail::tvec2<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
m[0][0] = c[0] * r[0];
m[0][1] = c[1] * r[0];
m[1][0] = c[0] * r[1];
m[1][1] = c[1] * r[1];
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
(
detail::tvec3<T> const & c,
detail::tvec3<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
for(typename detail::tmat3x3<T>::size_type i(0); i < m.length(); ++i)
m[i] = c * r[i];
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
(
detail::tvec4<T> const & c,
detail::tvec4<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
for(typename detail::tmat4x4<T>::size_type i(0); i < m.length(); ++i)
m[i] = c * r[i];
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> outerProduct
(
detail::tvec3<T> const & c,
detail::tvec2<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat2x3<T> m(detail::tmat2x3<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[1][2] = c.z * r.y;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> outerProduct
(
detail::tvec2<T> const & c,
detail::tvec3<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat3x2<T> m(detail::tmat3x2<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[2][0] = c.x * r.z;
m[2][1] = c.y * r.z;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> outerProduct
(
detail::tvec4<T> const & c,
detail::tvec2<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat2x4<T> m(detail::tmat2x4<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
m[0][3] = c.w * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[1][2] = c.z * r.y;
m[1][3] = c.w * r.y;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> outerProduct
(
detail::tvec2<T> const & c,
detail::tvec4<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat4x2<T> m(detail::tmat4x2<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[2][0] = c.x * r.z;
m[2][1] = c.y * r.z;
m[3][0] = c.x * r.w;
m[3][1] = c.y * r.w;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> outerProduct
(
detail::tvec4<T> const & c,
detail::tvec3<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat3x4<T> m(detail::tmat3x4<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
m[0][3] = c.w * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[1][2] = c.z * r.y;
m[1][3] = c.w * r.y;
m[2][0] = c.x * r.z;
m[2][1] = c.y * r.z;
m[2][2] = c.z * r.z;
m[2][3] = c.w * r.z;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> outerProduct
(
detail::tvec3<T> const & c,
detail::tvec4<T> const & r
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
detail::tmat4x3<T> m(detail::tmat4x3<T>::null);
m[0][0] = c.x * r.x;
m[0][1] = c.y * r.x;
m[0][2] = c.z * r.x;
m[1][0] = c.x * r.y;
m[1][1] = c.y * r.y;
m[1][2] = c.z * r.y;
m[2][0] = c.x * r.z;
m[2][1] = c.y * r.z;
m[2][2] = c.z * r.z;
m[3][0] = c.x * r.w;
m[3][1] = c.y * r.w;
m[3][2] = c.z * r.w;
return m;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
(
detail::tmat2x2<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
(
detail::tmat3x3<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
result[2][2] = m[2][2];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
(
detail::tmat4x4<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[0][3] = m[3][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
result[1][3] = m[3][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
result[2][2] = m[2][2];
result[2][3] = m[3][2];
result[3][0] = m[0][3];
result[3][1] = m[1][3];
result[3][2] = m[2][3];
result[3][3] = m[3][3];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
(
detail::tmat3x2<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
(
detail::tmat2x3<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> transpose
(
detail::tmat4x2<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[0][3] = m[3][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
result[1][3] = m[3][1];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> transpose
(
detail::tmat2x4<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
result[3][0] = m[0][3];
result[3][1] = m[1][3];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> transpose
(
detail::tmat4x3<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[0][3] = m[3][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
result[1][3] = m[3][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
result[2][2] = m[2][2];
result[2][3] = m[3][2];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> transpose
(
detail::tmat3x4<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
result[0][0] = m[0][0];
result[0][1] = m[1][0];
result[0][2] = m[2][0];
result[1][0] = m[0][1];
result[1][1] = m[1][1];
result[1][2] = m[2][1];
result[2][0] = m[0][2];
result[2][1] = m[1][2];
result[2][2] = m[2][2];
result[3][0] = m[0][3];
result[3][1] = m[1][3];
result[3][2] = m[2][3];
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tmat2x2<T>::value_type determinant
(
detail::tmat2x2<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
return m[0][0] * m[1][1] - m[1][0] * m[0][1];
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tmat3x3<T>::value_type determinant
(
detail::tmat3x3<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
return
+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER typename detail::tmat4x4<T>::value_type determinant
(
detail::tmat4x4<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
detail::tvec4<T> DetCof(
+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
return m[0][0] * DetCof[0]
+ m[0][1] * DetCof[1]
+ m[0][2] * DetCof[2]
+ m[0][3] * DetCof[3];
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> inverse
(
detail::tmat2x2<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
T Determinant = determinant(m);
detail::tmat2x2<T> Inverse(
+ m[1][1] / Determinant,
- m[0][1] / Determinant,
- m[1][0] / Determinant,
+ m[0][0] / Determinant);
return Inverse;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> inverse
(
detail::tmat3x3<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
//valType Determinant = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
// - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
// + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
T Determinant = determinant(m);
detail::tmat3x3<T> Inverse(detail::tmat3x3<T>::null);
Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
Inverse /= Determinant;
return Inverse;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> inverse
(
detail::tmat4x4<T> const & m
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
detail::tvec4<T> const SignA(+1, -1, +1, -1);
detail::tvec4<T> const SignB(-1, +1, -1, +1);
detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
T Determinant = glm::dot(m[0], Row0);
Inverse /= Determinant;
return Inverse;
}
}//namespace glm

87
Glm/core/func_noise.hpp

@ -0,0 +1,87 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_noise.hpp
/// @date 2008-08-01 / 2011-06-18
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
///
/// @defgroup core_func_noise Noise functions
/// @ingroup core
///
/// Noise functions are stochastic functions that can be used to increase visual
/// complexity. Values returned by the following noise functions give the
/// appearance of randomness, but are not truly random.
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_func_noise
#define glm_core_func_noise GLM_VERSION
namespace glm
{
/// @addtogroup core_func_noise
/// @{
/// Returns a 1D noise value based on the input value x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
/// Returns a 2D noise value based on the input value x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec2<typename genType::value_type> noise2(genType const & x);
/// Returns a 3D noise value based on the input value x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec3<typename genType::value_type> noise3(genType const & x);
/// Returns a 4D noise value based on the input value x.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
template <typename genType>
GLM_FUNC_DECL detail::tvec4<typename genType::value_type> noise4(genType const & x);
/// @}
}//namespace glm
#include "func_noise.inl"
#endif//glm_core_func_noise

364
Glm/core/func_noise.inl

@ -0,0 +1,364 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_noise.inl
/// @date 2008-08-01 / 2011-09-27
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T>
GLM_FUNC_QUALIFIER T noise1(T const & x)
{
return noise1(glm::detail::tvec2<T>(x, T(0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(T const & x)
{
return glm::detail::tvec2<T>(
noise1(x + T(0.0)),
noise1(x + T(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(T const & x)
{
return glm::detail::tvec3<T>(
noise1(x - T(1.0)),
noise1(x + T(0.0)),
noise1(x + T(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(T const & x)
{
return glm::detail::tvec4<T>(
noise1(x - T(1.0)),
noise1(x + T(0.0)),
noise1(x + T(1.0)),
noise1(x + T(2.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER T noise1(glm::detail::tvec2<T> const & v)
{
detail::tvec4<T> const C = detail::tvec4<T>(
T( 0.211324865405187), // (3.0 - sqrt(3.0)) / 6.0
T( 0.366025403784439), // 0.5 * (sqrt(3.0) - 1.0)
T(-0.577350269189626), // -1.0 + 2.0 * C.x
T( 0.024390243902439)); // 1.0 / 41.0
// First corner
detail::tvec2<T> i = floor(v + dot(v, detail::tvec2<T>(C[1])));
detail::tvec2<T> x0 = v - i + dot(i, detail::tvec2<T>(C[0]));
// Other corners
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
// Permutations
i = mod(i, T(289)); // Avoid truncation effects in permutation
detail::tvec3<T> p = permute(
permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
dot(x0, x0),
dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)),
dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
m = m * m ;
m = m * m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
detail::tvec3<T> h = abs(x) - T(0.5);
detail::tvec3<T> ox = floor(x + T(0.5));
detail::tvec3<T> a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
// Compute final noise value at P
detail::tvec3<T> g;
g.x = a0.x * x0.x + h.x * x0.y;
//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
g.y = a0.y * x12.x + h.y * x12.y;
g.z = a0.z * x12.z + h.z * x12.w;
return T(130) * dot(m, g);
}
template <typename T>
GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T> const & v)
{
detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
// First corner
detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
// Other corners
detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
detail::tvec3<T> l(T(1) - g);
detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
detail::tvec3<T> x1(x0 - i1 + C.x);
detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
detail::tvec3<T> x3(x0 - D.y); // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
detail::tvec4<T> p(permute(permute(permute(
i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) +
i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) +
i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
T n_ = T(0.142857142857); // 1.0/7.0
detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z)); // mod(p,7*7)
detail::tvec4<T> x_(floor(j * ns.z));
detail::tvec4<T> y_(floor(j - T(7) * x_)); // mod(j,N)
detail::tvec4<T> x(x_ * ns.x + ns.y);
detail::tvec4<T> y(y_ * ns.x + ns.y);
detail::tvec4<T> h(T(1) - abs(x) - abs(y));
detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
detail::tvec3<T> p0(a0.x, a0.y, h.x);
detail::tvec3<T> p1(a0.z, a0.w, h.y);
detail::tvec3<T> p2(a1.x, a1.y, h.z);
detail::tvec3<T> p3(a1.z, a1.w, h.w);
// Normalise gradients
detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
m = m * m;
return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
}
template <typename T>
GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T> const & v)
{
detail::tvec4<T> const C(
0.138196601125011, // (5 - sqrt(5))/20 G4
0.276393202250021, // 2 * G4
0.414589803375032, // 3 * G4
-0.447213595499958); // -1 + 4 * G4
// (sqrt(5) - 1)/4 = F4, used once below
T const F4 = T(0.309016994374947451);
// First corner
detail::tvec4<T> i = floor(v + dot(v, vec4(F4)));
detail::tvec4<T> x0 = v - i + dot(i, vec4(C.x));
// Other corners
// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
detail::tvec4<T> i0;
detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
// i0.x = dot(isX, vec3(1.0));
//i0.x = isX.x + isX.y + isX.z;
//i0.yzw = T(1) - isX;
i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
// i0.y += dot(isYZ.xy, vec2(1.0));
i0.y += isYZ.x + isYZ.y;
//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
i0.z += T(1) - isYZ.x;
i0.w += T(1) - isYZ.y;
i0.z += isYZ.z;
i0.w += T(1) - isYZ.z;
// i0 now contains the unique values 0,1,2,3 in each channel
detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xxxx
// x1 = x0 - i1 + 0.0 * C.xxxx
// x2 = x0 - i2 + 0.0 * C.xxxx
// x3 = x0 - i3 + 0.0 * C.xxxx
// x4 = x0 - 1.0 + 4.0 * C.xxxx
detail::tvec4<T> x1 = x0 - i1 + C.x;
detail::tvec4<T> x2 = x0 - i2 + C.y;
detail::tvec4<T> x3 = x0 - i3 + C.z;
detail::tvec4<T> x4 = x0 + C.w;
// Permutations
i = mod(i, T(289));
T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
detail::tvec4<T> j1 = permute(permute(permute(permute(
i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
+ i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
+ i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
+ i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
detail::tvec4<T> p0 = grad4(j0, ip);
detail::tvec4<T> p1 = grad4(j1.x, ip);
detail::tvec4<T> p2 = grad4(j1.y, ip);
detail::tvec4<T> p3 = grad4(j1.z, ip);
detail::tvec4<T> p4 = grad4(j1.w, ip);
// Normalise gradients
detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
p4 *= taylorInvSqrt(dot(p4, p4));
// Mix contributions from the five corners
detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4) ), T(0));
m0 = m0 * m0;
m1 = m1 * m1;
return T(49) *
(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec2<T> const & x)
{
return glm::detail::tvec2<T>(
noise1(x + glm::detail::tvec2<T>(0.0)),
noise1(glm::detail::tvec2<T>(0.0) - x));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec3<T> const & x)
{
return glm::detail::tvec2<T>(
noise1(x + glm::detail::tvec3<T>(0.0)),
noise1(glm::detail::tvec3<T>(0.0) - x));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec4<T> const & x)
{
return glm::detail::tvec2<T>(
noise1(x + glm::detail::tvec4<T>(0.0)),
noise1(glm::detail::tvec4<T>(0.0) - x));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec2<T> const & x)
{
return glm::detail::tvec3<T>(
noise1(x - glm::detail::tvec2<T>(1.0)),
noise1(x + glm::detail::tvec2<T>(0.0)),
noise1(x + glm::detail::tvec2<T>(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec3<T> const & x)
{
return glm::detail::tvec3<T>(
noise1(x - glm::detail::tvec3<T>(1.0)),
noise1(x + glm::detail::tvec3<T>(0.0)),
noise1(x + glm::detail::tvec3<T>(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec4<T> const & x)
{
return glm::detail::tvec3<T>(
noise1(x - glm::detail::tvec4<T>(1.0)),
noise1(x + glm::detail::tvec4<T>(0.0)),
noise1(x + glm::detail::tvec4<T>(1.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec2<T> const & x)
{
return glm::detail::tvec4<T>(
noise1(x - glm::detail::tvec2<T>(1.0)),
noise1(x + glm::detail::tvec2<T>(0.0)),
noise1(x + glm::detail::tvec2<T>(1.0)),
noise1(x + glm::detail::tvec2<T>(2.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec3<T> const & x)
{
return glm::detail::tvec4<T>(
noise1(x - glm::detail::tvec3<T>(1.0)),
noise1(x + glm::detail::tvec3<T>(0.0)),
noise1(x + glm::detail::tvec3<T>(1.0)),
noise1(x + glm::detail::tvec3<T>(2.0)));
}
template <typename T>
GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec4<T> const & x)
{
return glm::detail::tvec4<T>(
noise1(x - glm::detail::tvec4<T>(1.0)),
noise1(x + glm::detail::tvec4<T>(0.0)),
noise1(x + glm::detail::tvec4<T>(1.0)),
noise1(x + glm::detail::tvec4<T>(2.0)));
}
}//namespace glm

193
Glm/core/func_packing.hpp

@ -0,0 +1,193 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_packing.hpp
/// @date 2010-03-17 / 2011-06-15
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
///
/// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
/// @ingroup core
///
/// These functions do not operate component-wise, rather as described in each case.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_func_packing
#define GLM_CORE_func_packing GLM_VERSION
namespace glm
{
/// @addtogroup core_func_packing
/// @{
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer.
//!
//! The conversion for component c of v to fixed point is done as follows:
//! packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
//!
//! The first component of the vector will be written to the least significant bits of the output;
//! the last component will be written to the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer.
//!
//! The conversion for component c of v to fixed point is done as follows:
//! packSnorm2x16: round(clamp(v, -1, +1) * 32767.0)
//!
//! The first component of the vector will be written to the least significant bits of the output;
//! the last component will be written to the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer.
//!
//! The conversion for component c of v to fixed point is done as follows:
//! packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
//!
//! The first component of the vector will be written to the least significant bits of the output;
//! the last component will be written to the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! Then, the results are packed into the returned 32-bit unsigned integer.
//!
//! The conversion for component c of v to fixed point is done as follows:
//! packSnorm4x8: round(clamp(c, -1, +1) * 127.0)
//!
//! The first component of the vector will be written to the least significant bits of the output;
//! the last component will be written to the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
//!
//! The conversion for unpacked fixed-point value f to floating point is done as follows:
//! unpackUnorm2x16: f / 65535.0
//!
//! The first component of the returned vector will be extracted from the least significant bits of the input;
//! the last component will be extracted from the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
//!
//! The conversion for unpacked fixed-point value f to floating point is done as follows:
//! unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
//!
//! The first component of the returned vector will be extracted from the least significant bits of the input;
//! the last component will be extracted from the most significant bits.
//!
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p);
/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
///
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
/// unpackUnorm4x8: f / 255.0
///
/// The first component of the returned vector will be extracted from the least significant bits of the input;
/// the last component will be extracted from the most significant bits.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
///
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
/// unpackSnorm4x8: clamp(f / 127.0, -1, +1)
///
/// The first component of the returned vector will be extracted from the least significant bits of the input;
/// the last component will be extracted from the most significant bits.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
/// Returns a double-precision value obtained by packing the components of v into a 64-bit value.
/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified.
/// Otherwise, the bit- level representation of v is preserved.
/// The first vector component specifies the 32 least significant bits;
/// the second component specifies the 32 most significant bits.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL double packDouble2x32(detail::tvec2<detail::uint32> const & v);
/// Returns a two-component unsigned integer vector representation of v.
/// The bit-level representation of v is preserved.
/// The first component of the vector contains the 32 least significant bits of the double;
/// the second component consists the 32 most significant bits.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector
/// to the 16-bit floating-point representation found in the OpenGL Specification,
/// and then packing these two 16- bit integers into a 32-bit unsigned integer.
/// The first vector component specifies the 16 least-significant bits of the result;
/// the second component specifies the 16 most-significant bits.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint packHalf2x16(vec2 const & v);
/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values,
/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
/// and converting them to 32-bit floating-point values.
/// The first component of the vector is obtained from the 16 least-significant bits of v;
/// the second component is obtained from the 16 most-significant bits of v.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec2 unpackHalf2x16(uint const & v);
/// @}
}//namespace glm
#include "func_packing.inl"
#endif//GLM_CORE_func_packing

208
Glm/core/func_packing.inl

@ -0,0 +1,208 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_packing.inl
/// @date 2010-03-17 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
{
detail::uint16 A(detail::uint16(round(clamp(v.x, 0.0f, 1.0f) * 65535.0f)));
detail::uint16 B(detail::uint16(round(clamp(v.y, 0.0f, 1.0f) * 65535.0f)));
return detail::uint32((B << 16) | A);
}
GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
{
detail::uint32 Mask16((1 << 16) - 1);
detail::uint32 A((p >> 0) & Mask16);
detail::uint32 B((p >> 16) & Mask16);
return detail::tvec2<detail::float32>(
A * 1.0f / 65535.0f,
B * 1.0f / 65535.0f);
}
GLM_FUNC_QUALIFIER detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v)
{
union iu
{
detail::int16 i;
detail::uint16 u;
} A, B;
detail::tvec2<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 32767.0f;
A.i = detail::int16(round(Unpack.x));
B.i = detail::int16(round(Unpack.y));
detail::uint32 Pack = (detail::uint32(B.u) << 16) | (detail::uint32(A.u) << 0);
return Pack;
}
GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p)
{
union iu
{
detail::int16 i;
detail::uint16 u;
} A, B;
detail::uint32 Mask16((1 << 16) - 1);
A.u = detail::uint16((p >> 0) & Mask16);
B.u = detail::uint16((p >> 16) & Mask16);
detail::tvec2<detail::float32> Pack(A.i, B.i);
return clamp(Pack * 1.0f / 32767.0f, -1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
{
detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
}
GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
{
detail::uint32 Mask8((1 << 8) - 1);
detail::uint32 A((p >> 0) & Mask8);
detail::uint32 B((p >> 8) & Mask8);
detail::uint32 C((p >> 16) & Mask8);
detail::uint32 D((p >> 24) & Mask8);
return detail::tvec4<detail::float32>(
A * 1.0f / 255.0f,
B * 1.0f / 255.0f,
C * 1.0f / 255.0f,
D * 1.0f / 255.0f);
}
GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
{
union iu
{
detail::int8 i;
detail::uint8 u;
} A, B, C, D;
detail::tvec4<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 127.0f;
A.i = detail::int8(round(Unpack.x));
B.i = detail::int8(round(Unpack.y));
C.i = detail::int8(round(Unpack.z));
D.i = detail::int8(round(Unpack.w));
detail::uint32 Pack = (detail::uint32(D.u) << 24) | (detail::uint32(C.u) << 16) | (detail::uint32(B.u) << 8) | (detail::uint32(A.u) << 0);
return Pack;
}
GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
{
union iu
{
detail::int8 i;
detail::uint8 u;
} A, B, C, D;
detail::uint32 Mask8((1 << 8) - 1);
A.u = detail::uint8((p >> 0) & Mask8);
B.u = detail::uint8((p >> 8) & Mask8);
C.u = detail::uint8((p >> 16) & Mask8);
D.u = detail::uint8((p >> 24) & Mask8);
detail::tvec4<detail::float32> Pack(A.i, B.i, C.i, D.i);
return clamp(Pack * 1.0f / 127.0f, -1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
{
struct uint32_pair
{
detail::uint32 x;
detail::uint32 y;
};
union helper
{
uint32_pair input;
double output;
} Helper;
Helper.input.x = v.x;
Helper.input.y = v.y;
return Helper.output;
//return *(double*)&v;
}
GLM_FUNC_QUALIFIER detail::tvec2<uint> unpackDouble2x32(double const & v)
{
struct uint32_pair
{
detail::uint32 x;
detail::uint32 y;
};
union helper
{
double input;
uint32_pair output;
} Helper;
Helper.input = v;
return detail::tvec2<uint>(Helper.output.x, Helper.output.y);
}
GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2<float> const & v)
{
union helper
{
uint other;
struct
{
detail::hdata a, b;
} orig;
} Pack;
Pack.orig.a = detail::toFloat16(v.x);
Pack.orig.b = detail::toFloat16(v.y);
return Pack.other;
}
GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
{
union helper
{
uint other;
struct
{
detail::hdata a, b;
} orig;
} Unpack;
Unpack.other = v;
return vec2(detail::toFloat32(Unpack.orig.a), detail::toFloat32(Unpack.orig.b));
}
}//namespace glm

203
Glm/core/func_trigonometric.hpp

@ -0,0 +1,203 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_trigonometric.hpp
/// @date 2008-08-01 / 2011-06-15
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
///
/// @defgroup core_func_trigonometric Angle and Trigonometry Functions
/// @ingroup core
///
/// Function parameters specified as angle are assumed to be in units of radians.
/// In no case will any of these functions result in a divide by zero error. If
/// the divisor of a ratio is 0, then results will be undefined.
///
/// These all operate component-wise. The description is per component.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_func_trigonometric
#define GLM_CORE_func_trigonometric GLM_VERSION
namespace glm
{
/// @addtogroup core_func_trigonometric
/// @{
/// Converts degrees to radians and returns the result.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType radians(genType const & degrees);
/// Converts radians to degrees and returns the result.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType degrees(genType const & radians);
/// The standard trigonometric sine function.
/// The values returned by this function will range from [-1, 1].
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType sin(genType const & angle);
/// The standard trigonometric cosine function.
/// The values returned by this function will range from [-1, 1].
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType cos(genType const & angle);
/// The standard trigonometric tangent function.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType tan(genType const & angle);
/// Arc sine. Returns an angle whose sine is x.
/// The range of values returned by this function is [-PI/2, PI/2].
/// Results are undefined if |x| > 1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType asin(genType const & x);
/// Arc cosine. Returns an angle whose sine is x.
/// The range of values returned by this function is [0, PI].
/// Results are undefined if |x| > 1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType acos(genType const & x);
/// Arc tangent. Returns an angle whose tangent is y/x.
/// The signs of x and y are used to determine what
/// quadrant the angle is in. The range of values returned
/// by this function is [-PI, PI]. Results are undefined
/// if x and y are both 0.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
/// Arc tangent. Returns an angle whose tangent is y_over_x.
/// The range of values returned by this function is [-PI/2, PI/2].
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType atan(genType const & y_over_x);
/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType sinh(genType const & angle);
/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType cosh(genType const & angle);
/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType tanh(genType const & angle);
/// Arc hyperbolic sine; returns the inverse of sinh.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType asinh(genType const & x);
/// Arc hyperbolic cosine; returns the non-negative inverse
/// of cosh. Results are undefined if x < 1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType acosh(genType const & x);
/// Arc hyperbolic tangent; returns the inverse of tanh.
/// Results are undefined if abs(x) >= 1.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template <typename genType>
GLM_FUNC_DECL genType atanh(genType const & x);
/// @}
}//namespace glm
#include "func_trigonometric.inl"
#endif//GLM_CORE_func_trigonometric

244
Glm/core/func_trigonometric.inl

@ -0,0 +1,244 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_trigonometric.inl
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// radians
template <typename genType>
GLM_FUNC_QUALIFIER genType radians
(
genType const & degrees
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
genType const pi = genType(3.1415926535897932384626433832795);
return degrees * (pi / genType(180));
}
VECTORIZE_VEC(radians)
// degrees
template <typename genType>
GLM_FUNC_QUALIFIER genType degrees
(
genType const & radians
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
const genType pi = genType(3.1415926535897932384626433832795);
return radians * (genType(180) / pi);
}
VECTORIZE_VEC(degrees)
// sin
template <typename genType>
GLM_FUNC_QUALIFIER genType sin
(
genType const & angle
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
return genType(::std::sin(angle));
}
VECTORIZE_VEC(sin)
// cos
template <typename genType>
GLM_FUNC_QUALIFIER genType cos(genType const & angle)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
return genType(::std::cos(angle));
}
VECTORIZE_VEC(cos)
// tan
template <typename genType>
GLM_FUNC_QUALIFIER genType tan
(
genType const & angle
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
return genType(::std::tan(angle));
}
VECTORIZE_VEC(tan)
// asin
template <typename genType>
GLM_FUNC_QUALIFIER genType asin
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
return genType(::std::asin(x));
}
VECTORIZE_VEC(asin)
// acos
template <typename genType>
GLM_FUNC_QUALIFIER genType acos
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
return genType(::std::acos(x));
}
VECTORIZE_VEC(acos)
// atan
template <typename genType>
GLM_FUNC_QUALIFIER genType atan
(
genType const & y,
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
return genType(::std::atan2(y, x));
}
VECTORIZE_VEC_VEC(atan)
template <typename genType>
GLM_FUNC_QUALIFIER genType atan
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
return genType(::std::atan(x));
}
VECTORIZE_VEC(atan)
// sinh
template <typename genType>
GLM_FUNC_QUALIFIER genType sinh
(
genType const & angle
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
return genType(std::sinh(angle));
}
VECTORIZE_VEC(sinh)
// cosh
template <typename genType>
GLM_FUNC_QUALIFIER genType cosh
(
genType const & angle
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
return genType(std::cosh(angle));
}
VECTORIZE_VEC(cosh)
// tanh
template <typename genType>
GLM_FUNC_QUALIFIER genType tanh
(
genType const & angle
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
return genType(std::tanh(angle));
}
VECTORIZE_VEC(tanh)
// asinh
template <typename genType>
GLM_FUNC_QUALIFIER genType asinh
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
}
VECTORIZE_VEC(asinh)
// acosh
template <typename genType>
GLM_FUNC_QUALIFIER genType acosh
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
if(x < genType(1))
return genType(0);
return log(x + sqrt(x * x - genType(1)));
}
VECTORIZE_VEC(acosh)
// atanh
template <typename genType>
GLM_FUNC_QUALIFIER genType atanh
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
if(abs(x) >= genType(1))
return 0;
return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
}
VECTORIZE_VEC(atanh)
}//namespace glm

138
Glm/core/func_vector_relational.hpp

@ -0,0 +1,138 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_vector_relational.hpp
/// @date 2008-08-03 / 2011-06-15
/// @author Christophe Riccio
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
///
/// @defgroup core_func_vector_relational Vector Relational Functions
/// @ingroup core
///
/// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to
/// operate on scalars and produce scalar Boolean results. For vector results,
/// use the following built-in functions.
///
/// In all cases, the sizes of all the input and return vectors for any particular
/// call must match.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_CORE_func_vector_relational
#define GLM_CORE_func_vector_relational GLM_VERSION
#include "_detail.hpp"
namespace glm
{
/// @addtogroup core_func_vector_relational
/// @{
/// Returns the component-wise comparison result of x < y.
///
/// @tparam vecType Floating-point or integer vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type lessThan(vecType const & x, vecType const & y);
/// Returns the component-wise comparison of result x <= y.
///
/// @tparam vecType Floating-point or integer vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
/// Returns the component-wise comparison of result x > y.
///
/// @tparam vecType Floating-point or integer vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type greaterThan(vecType const & x, vecType const & y);
/// Returns the component-wise comparison of result x >= y.
///
/// @tparam vecType Floating-point or integer vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
/// Returns the component-wise comparison of result x == y.
///
/// @tparam vecType Floating-point, integer or boolean vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type equal(vecType const & x, vecType const & y);
/// Returns the component-wise comparison of result x != y.
///
/// @tparam vecType Floating-point, integer or boolean vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <typename vecType>
GLM_FUNC_DECL typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
/// Returns true if any component of x is true.
///
/// @tparam vecType Boolean vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <template <typename> class vecType>
GLM_FUNC_DECL bool any(vecType<bool> const & v);
/// Returns true if all components of x are true.
///
/// @tparam vecType Boolean vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <template <typename> class vecType>
GLM_FUNC_DECL bool all(vecType<bool> const & v);
/// Returns the component-wise logical complement of x.
/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
///
/// @tparam vecType Boolean vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template <template <typename> class vecType>
GLM_FUNC_DECL vecType<bool> not_(vecType<bool> const & v);
/// @}
}//namespace glm
#include "func_vector_relational.inl"
#endif//GLM_CORE_func_vector_relational

178
Glm/core/func_vector_relational.inl

@ -0,0 +1,178 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/func_vector_relational.inl
/// @date 2008-08-03 / 2011-09-09
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'lessThan', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] < y[i];
return Result;
}
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'lessThanEqual', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] <= y[i];
return Result;
}
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'greaterThan', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] > y[i];
return Result;
}
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'greaterThanEqual', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] >= y[i];
return Result;
}
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'equal', GLM vector types required");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] == y[i];
return Result;
}
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
"Invalid template instantiation of 'notEqual', GLM vector types required");
assert(x.length() == y.length());
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
Result[i] = x[i] != y[i];
return Result;
}
template <template <typename> class vecType>
GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
"Invalid template instantiation of 'any', GLM boolean vector types required");
bool Result = false;
for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
Result = Result || v[i];
return Result;
}
template <template <typename> class vecType>
GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
"Invalid template instantiation of 'all', GLM boolean vector types required");
bool Result = true;
for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
Result = Result && v[i];
return Result;
}
template <template <typename> class vecType>
GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v)
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
"Invalid template instantiation of 'not_', GLM vector types required");
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
Result[i] = !v[i];
return Result;
}
}//namespace glm

40
Glm/core/hint.hpp

@ -0,0 +1,40 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/hint.hpp
/// @date 2008-08-14 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type
#define glm_core_type
namespace glm
{
// Use dont_care, nicest and fastest to optimize implementations.
class dont_care {};
class nicest {};
class fastest {};
}//namespace glm
#endif//glm_core_type

89
Glm/core/intrinsic_common.hpp

@ -0,0 +1,89 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_common.hpp
/// @date 2009-05-11 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_detail_intrinsic_common
#define glm_detail_intrinsic_common
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
namespace glm{
namespace detail
{
__m128 sse_abs_ps(__m128 x);
__m128 sse_sgn_ps(__m128 x);
//floor
__m128 sse_flr_ps(__m128 v);
//trunc
__m128 sse_trc_ps(__m128 v);
//round
__m128 sse_nd_ps(__m128 v);
//roundEven
__m128 sse_rde_ps(__m128 v);
__m128 sse_rnd_ps(__m128 x);
__m128 sse_ceil_ps(__m128 v);
__m128 sse_frc_ps(__m128 x);
__m128 sse_mod_ps(__m128 x, __m128 y);
__m128 sse_modf_ps(__m128 x, __m128i & i);
//GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
//GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
__m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
__m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
__m128 sse_stp_ps(__m128 edge, __m128 x);
__m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
__m128 sse_nan_ps(__m128 x);
__m128 sse_inf_ps(__m128 x);
}//namespace detail
}//namespace glm
#include "intrinsic_common.inl"
#endif//GLM_ARCH
#endif//glm_detail_intrinsic_common

313
Glm/core/intrinsic_common.inl

@ -0,0 +1,313 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_common.inl
/// @date 2009-05-08 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail{
#if(GLM_COMPILER & GLM_COMPILER_VC)
#pragma warning(push)
#pragma warning(disable : 4510 4512 4610)
#endif
union ieee754_QNAN
{
const float f;
struct i
{
const unsigned int mantissa:23, exp:8, sign:1;
};
ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
};
#if(GLM_COMPILER & GLM_COMPILER_VC)
#pragma warning(pop)
#endif
static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
static const __m128 GLM_VAR_USED two = _mm_set_ps1(2.0f);
static const __m128 GLM_VAR_USED three = _mm_set_ps1(3.0f);
static const __m128 GLM_VAR_USED pi = _mm_set_ps1(3.1415926535897932384626433832795f);
static const __m128 GLM_VAR_USED hundred_eighty = _mm_set_ps1(180.f);
static const __m128 GLM_VAR_USED pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
static const __m128 GLM_VAR_USED hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
static const ieee754_QNAN absMask;
static const __m128 GLM_VAR_USED abs4Mask = _mm_set_ps1(absMask.f);
static const __m128 GLM_VAR_USED _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(static_cast<int>(0x80000000)));
//static const __m128 GLM_VAR_USED _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
//static const __m128 GLM_VAR_USED _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
//static const __m128 GLM_VAR_USED _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
//static const __m128 GLM_VAR_USED _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
static const __m128 GLM_VAR_USED _epi32_0 = _mm_set_ps1(0);
static const __m128 GLM_VAR_USED _epi32_1 = _mm_set_ps1(1);
static const __m128 GLM_VAR_USED _epi32_2 = _mm_set_ps1(2);
static const __m128 GLM_VAR_USED _epi32_3 = _mm_set_ps1(3);
static const __m128 GLM_VAR_USED _epi32_4 = _mm_set_ps1(4);
static const __m128 GLM_VAR_USED _epi32_5 = _mm_set_ps1(5);
static const __m128 GLM_VAR_USED _epi32_6 = _mm_set_ps1(6);
static const __m128 GLM_VAR_USED _epi32_7 = _mm_set_ps1(7);
static const __m128 GLM_VAR_USED _epi32_8 = _mm_set_ps1(8);
static const __m128 GLM_VAR_USED _epi32_9 = _mm_set_ps1(9);
static const __m128 GLM_VAR_USED _epi32_127 = _mm_set_ps1(127);
//static const __m128 GLM_VAR_USED _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
//static const __m128 GLM_VAR_USED _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
static const __m128 GLM_VAR_USED _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
static const __m128 GLM_VAR_USED _ps_0p5 = _mm_set_ps1(0.5f);
static const __m128 GLM_VAR_USED _ps_1 = _mm_set_ps1(1.0f);
static const __m128 GLM_VAR_USED _ps_m1 = _mm_set_ps1(-1.0f);
static const __m128 GLM_VAR_USED _ps_2 = _mm_set_ps1(2.0f);
static const __m128 GLM_VAR_USED _ps_3 = _mm_set_ps1(3.0f);
static const __m128 GLM_VAR_USED _ps_127 = _mm_set_ps1(127.0f);
static const __m128 GLM_VAR_USED _ps_255 = _mm_set_ps1(255.0f);
static const __m128 GLM_VAR_USED _ps_2pow23 = _mm_set_ps1(8388608.0f);
static const __m128 GLM_VAR_USED _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
static const __m128 GLM_VAR_USED _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
static const __m128 GLM_VAR_USED _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
static const __m128 GLM_VAR_USED _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
static const __m128 GLM_VAR_USED _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
static const __m128 GLM_VAR_USED _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
static const __m128 GLM_VAR_USED _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
static const __m128 GLM_VAR_USED _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
static const __m128 GLM_VAR_USED _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
static const __m128 GLM_VAR_USED _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
static const __m128 GLM_VAR_USED _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
static const __m128 GLM_VAR_USED _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
static const __m128 GLM_VAR_USED _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
static const __m128 GLM_VAR_USED _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
static const __m128 GLM_VAR_USED _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
static const __m128 GLM_VAR_USED _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
static const __m128 GLM_VAR_USED _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
static const __m128 GLM_VAR_USED _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
static const __m128 GLM_VAR_USED _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
static const __m128 GLM_VAR_USED _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
static const __m128 GLM_VAR_USED _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
static const __m128 GLM_VAR_USED _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
static const __m128 GLM_VAR_USED _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
static const __m128 GLM_VAR_USED _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
static const __m128 GLM_VAR_USED _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
static const __m128 GLM_VAR_USED _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
static const __m128 GLM_VAR_USED _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
static const __m128 GLM_VAR_USED _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
static const __m128 GLM_VAR_USED _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
static const __m128 GLM_VAR_USED _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
static const __m128 GLM_VAR_USED _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
static const __m128 GLM_VAR_USED _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
static const __m128 GLM_VAR_USED _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
static const __m128 GLM_VAR_USED _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
static const __m128 GLM_VAR_USED _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
static const __m128 GLM_VAR_USED _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
static const __m128 GLM_VAR_USED _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
static const __m128 GLM_VAR_USED _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
static const __m128 GLM_VAR_USED _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
static const __m128 GLM_VAR_USED _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
static const __m128 GLM_VAR_USED _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
static const __m128 GLM_VAR_USED _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
static const __m128 GLM_VAR_USED _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
static const __m128 GLM_VAR_USED _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
static const __m128 GLM_VAR_USED _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
static const __m128 GLM_VAR_USED _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
static const __m128 GLM_VAR_USED _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
static const __m128 GLM_VAR_USED _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
static const __m128 GLM_VAR_USED _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
static const __m128 GLM_VAR_USED _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
static const __m128 GLM_VAR_USED _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
static const __m128 GLM_VAR_USED _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
static const __m128 GLM_VAR_USED _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
static const __m128 GLM_VAR_USED _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
static const __m128 GLM_VAR_USED _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
static const __m128 GLM_VAR_USED _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
GLM_FUNC_QUALIFIER __m128 sse_abs_ps(__m128 x)
{
return _mm_and_ps(glm::detail::abs4Mask, x);
}
GLM_FUNC_QUALIFIER __m128 sse_sgn_ps(__m128 x)
{
__m128 Neg = _mm_set1_ps(-1.0f);
__m128 Pos = _mm_set1_ps(1.0f);
__m128 Cmp0 = _mm_cmplt_ps(x, zero);
__m128 Cmp1 = _mm_cmpgt_ps(x, zero);
__m128 And0 = _mm_and_ps(Cmp0, Neg);
__m128 And1 = _mm_and_ps(Cmp1, Pos);
return _mm_or_ps(And0, And1);
}
//floor
GLM_FUNC_QUALIFIER __m128 sse_flr_ps(__m128 x)
{
__m128 rnd0 = sse_rnd_ps(x);
__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
__m128 sub0 = _mm_sub_ps(rnd0, and0);
return sub0;
}
//trunc
/*
GLM_FUNC_QUALIFIER __m128 _mm_trc_ps(__m128 v)
{
return __m128();
}
*/
//round
GLM_FUNC_QUALIFIER __m128 sse_rnd_ps(__m128 x)
{
__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
__m128 add0 = _mm_add_ps(x, or0);
__m128 sub0 = _mm_sub_ps(add0, or0);
return sub0;
}
//roundEven
GLM_FUNC_QUALIFIER __m128 sse_rde_ps(__m128 x)
{
__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
__m128 add0 = _mm_add_ps(x, or0);
__m128 sub0 = _mm_sub_ps(add0, or0);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 sse_ceil_ps(__m128 x)
{
__m128 rnd0 = sse_rnd_ps(x);
__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
__m128 add0 = _mm_add_ps(rnd0, and0);
return add0;
}
GLM_FUNC_QUALIFIER __m128 sse_frc_ps(__m128 x)
{
__m128 flr0 = sse_flr_ps(x);
__m128 sub0 = _mm_sub_ps(x, flr0);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
{
__m128 div0 = _mm_div_ps(x, y);
__m128 flr0 = sse_flr_ps(div0);
__m128 mul0 = _mm_mul_ps(y, flr0);
__m128 sub0 = _mm_sub_ps(x, mul0);
return sub0;
}
/// TODO
/*
GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
{
__m128 empty;
return empty;
}
*/
//GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
//GLM_FUNC_QUALIFIER __m128 _mm_max_ps(__m128 x, __m128 y)
GLM_FUNC_QUALIFIER __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
{
__m128 min0 = _mm_min_ps(v, maxVal);
__m128 max0 = _mm_max_ps(min0, minVal);
return max0;
}
GLM_FUNC_QUALIFIER __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a)
{
__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
__m128 mul0 = _mm_mul_ps(v1, sub0);
__m128 mul1 = _mm_mul_ps(v2, a);
__m128 add0 = _mm_add_ps(mul0, mul1);
return add0;
}
GLM_FUNC_QUALIFIER __m128 sse_stp_ps(__m128 edge, __m128 x)
{
__m128 cmp = _mm_cmple_ps(x, edge);
if(_mm_movemask_ps(cmp) == 0)
return glm::detail::one;
else
return glm::detail::zero;
}
GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
{
__m128 sub0 = _mm_sub_ps(x, edge0);
__m128 sub1 = _mm_sub_ps(edge1, edge0);
__m128 div0 = _mm_sub_ps(sub0, sub1);
__m128 clp0 = sse_clp_ps(div0, glm::detail::zero, glm::detail::one);
__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
__m128 mul1 = _mm_mul_ps(clp0, clp0);
__m128 mul2 = _mm_mul_ps(mul1, sub2);
return mul2;
}
/// \todo
//GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
//{
// __m128 empty;
// return empty;
//}
/// \todo
//GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
//{
// __m128 empty;
// return empty;
//}
// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
// By Elan Ruskin, http://assemblyrequired.crashworks.org/
GLM_FUNC_QUALIFIER __m128 sse_sqrt_wip_ss(__m128 const & x)
{
__m128 recip = _mm_rsqrt_ss(x); // "estimate" opcode
const static __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
const static __m128 half = {0.5,0.5,0.5,0.5};
__m128 halfrecip = _mm_mul_ss(half, recip);
__m128 threeminus_xrr = _mm_sub_ss(three, _mm_mul_ss(x, _mm_mul_ss (recip, recip)));
return _mm_mul_ss( halfrecip, threeminus_xrr);
}
}//namespace detail
}//namespace glms

79
Glm/core/intrinsic_exponential.hpp

@ -0,0 +1,79 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_exponential.hpp
/// @date 2009-05-11 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_detail_intrinsic_exponential
#define glm_detail_intrinsic_exponential
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
namespace glm{
namespace detail
{
/*
GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
{
__m128 recip = _mm_rsqrt_ss( x ); // "estimate" opcode
const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
const static __m128 half = { 0.5,0.5,0.5,0.5 };
__m128 halfrecip = _mm_mul_ss( half, recip );
__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
return _mm_mul_ss( halfrecip, threeminus_xrr );
}
GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps( float * RESTRICT vOut, float * RESTRICT vIn )
{
__m128 x = _mm_load_ss(&vIn[0]);
__m128 y = _mm_load_ss(&vIn[1]);
__m128 z = _mm_load_ss(&vIn[2]);
const __m128 l = // compute x*x + y*y + z*z
_mm_add_ss(
_mm_add_ss( _mm_mul_ss(x,x),
_mm_mul_ss(y,y)
),
_mm_mul_ss( z, z )
);
const __m128 rsqt = _mm_rsqrt_nr_ss( l );
_mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
_mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
_mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
return _mm_mul_ss( l , rsqt );
}
*/
}//namespace detail
}//namespace glm
#endif//GLM_ARCH
#endif//glm_detail_intrinsic_exponential

27
Glm/core/intrinsic_exponential.inl

@ -0,0 +1,27 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_exponential.inl
/// @date 2011-06-15 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////

76
Glm/core/intrinsic_geometric.hpp

@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_geometric.hpp
/// @date 2009-05-08 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_intrinsic_geometric
#define glm_core_intrinsic_geometric
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
#include "intrinsic_common.hpp"
namespace glm{
namespace detail
{
//length
__m128 sse_len_ps(__m128 x);
//distance
__m128 sse_dst_ps(__m128 p0, __m128 p1);
//dot
__m128 sse_dot_ps(__m128 v1, __m128 v2);
// SSE1
__m128 sse_dot_ss(__m128 v1, __m128 v2);
//cross
__m128 sse_xpd_ps(__m128 v1, __m128 v2);
//normalize
__m128 sse_nrm_ps(__m128 v);
//faceforward
__m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
//reflect
__m128 sse_rfe_ps(__m128 I, __m128 N);
//refract
__m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
}//namespace detail
}//namespace glm
#include "intrinsic_geometric.inl"
#endif//GLM_ARCH
#endif//glm_core_intrinsic_geometric

146
Glm/core/intrinsic_geometric.inl

@ -0,0 +1,146 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_geometric.inl
/// @date 2009-05-08 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail{
//length
GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
{
__m128 dot0 = sse_dot_ps(x, x);
__m128 sqt0 = _mm_sqrt_ps(dot0);
return sqt0;
}
//distance
GLM_FUNC_QUALIFIER __m128 sse_dst_ps(__m128 p0, __m128 p1)
{
__m128 sub0 = _mm_sub_ps(p0, p1);
__m128 len0 = sse_len_ps(sub0);
return len0;
}
//dot
GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
{
# if((GLM_ARCH & GLM_ARCH_SSE4) == GLM_ARCH_SSE4)
return _mm_dp_ps(v1, v2, 0xff);
# else
__m128 mul0 = _mm_mul_ps(v1, v2);
__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
__m128 add0 = _mm_add_ps(mul0, swp0);
__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
__m128 add1 = _mm_add_ps(add0, swp1);
return add1;
# endif
}
// SSE1
GLM_FUNC_QUALIFIER __m128 sse_dot_ss(__m128 v1, __m128 v2)
{
__m128 mul0 = _mm_mul_ps(v1, v2);
__m128 mov0 = _mm_movehl_ps(mul0, mul0);
__m128 add0 = _mm_add_ps(mov0, mul0);
__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
__m128 add1 = _mm_add_ss(add0, swp1);
return add1;
}
//cross
GLM_FUNC_QUALIFIER __m128 sse_xpd_ps(__m128 v1, __m128 v2)
{
__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
__m128 mul0 = _mm_mul_ps(swp0, swp3);
__m128 mul1 = _mm_mul_ps(swp1, swp2);
__m128 sub0 = _mm_sub_ps(mul0, mul1);
return sub0;
}
//normalize
GLM_FUNC_QUALIFIER __m128 sse_nrm_ps(__m128 v)
{
__m128 dot0 = sse_dot_ps(v, v);
__m128 isr0 = _mm_rsqrt_ps(dot0);
__m128 mul0 = _mm_mul_ps(v, isr0);
return mul0;
}
//faceforward
GLM_FUNC_QUALIFIER __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref)
{
//__m128 dot0 = _mm_dot_ps(v, v);
//__m128 neg0 = _mm_neg_ps(N);
//__m128 sgn0 = _mm_sgn_ps(dot0);
//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
//return mix0;
__m128 dot0 = sse_dot_ps(Nref, I);
__m128 sgn0 = sse_sgn_ps(dot0);
__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
__m128 mul1 = _mm_mul_ps(N, mul0);
return mul1;
}
//reflect
GLM_FUNC_QUALIFIER __m128 sse_rfe_ps(__m128 I, __m128 N)
{
__m128 dot0 = sse_dot_ps(N, I);
__m128 mul0 = _mm_mul_ps(N, dot0);
__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
__m128 sub0 = _mm_sub_ps(I, mul1);
return sub0;
}
//refract
GLM_FUNC_QUALIFIER __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta)
{
__m128 dot0 = sse_dot_ps(N, I);
__m128 mul0 = _mm_mul_ps(eta, eta);
__m128 mul1 = _mm_mul_ps(dot0, dot0);
__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
__m128 mul2 = _mm_mul_ps(sub0, sub1);
if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
return glm::detail::zero;
__m128 sqt0 = _mm_sqrt_ps(mul2);
__m128 mul3 = _mm_mul_ps(eta, dot0);
__m128 add0 = _mm_add_ps(mul3, sqt0);
__m128 mul4 = _mm_mul_ps(add0, N);
__m128 mul5 = _mm_mul_ps(eta, I);
__m128 sub2 = _mm_sub_ps(mul5, mul4);
return sub2;
}
}//namespace detail
}//namespace glm

69
Glm/core/intrinsic_matrix.hpp

@ -0,0 +1,69 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_common.hpp
/// @date 2009-06-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_detail_intrinsic_matrix
#define glm_detail_intrinsic_matrix
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
#include "intrinsic_geometric.hpp"
namespace glm{
namespace detail
{
void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
__m128 sse_mul_ps(__m128 m[4], __m128 v);
__m128 sse_mul_ps(__m128 v, __m128 m[4]);
void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
__m128 sse_det_ps(__m128 const m[4]);
__m128 sse_slow_det_ps(__m128 const m[4]);
}//namespace detail
}//namespace glm
#include "intrinsic_matrix.inl"
#endif//GLM_ARCH
#endif//glm_detail_intrinsic_matrix

1070
Glm/core/intrinsic_matrix.inl
File diff suppressed because it is too large
View File

48
Glm/core/intrinsic_trigonometric.hpp

@ -0,0 +1,48 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_trigonometric.hpp
/// @date 2009-06-09 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_detail_intrinsic_trigonometric
#define glm_detail_intrinsic_trigonometric
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
namespace glm{
namespace detail
{
}//namespace detail
}//namespace glm
#include "intrinsic_trigonometric.inl"
#endif//GLM_ARCH
#endif//glm_detail_intrinsic_trigonometric

27
Glm/core/intrinsic_trigonometric.inl

@ -0,0 +1,27 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_trigonometric.inl
/// @date 2011-06-15 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////

48
Glm/core/intrinsic_vector_relational.hpp

@ -0,0 +1,48 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_vector_relational.hpp
/// @date 2009-06-09 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_detail_intrinsic_vector_relational
#define glm_detail_intrinsic_vector_relational
#include "setup.hpp"
#if(!(GLM_ARCH & GLM_ARCH_SSE2))
# error "SSE2 instructions not supported or enabled"
#else
namespace glm{
namespace detail
{
}//namespace detail
}//namespace glm
#include "intrinsic_vector_relational.inl"
#endif//GLM_ARCH
#endif//glm_detail_intrinsic_vector_relational

366
Glm/core/intrinsic_vector_relational.inl

@ -0,0 +1,366 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/intrinsic_vector_relational.inl
/// @date 2009-06-09 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
//
//// lessThan
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThan
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThan
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThan
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
//}
//
//// lessThanEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThanEqual
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThanEqual
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThanEqual
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
//}
//
//// greaterThan
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThan
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThan
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThan
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
//}
//
//// greaterThanEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThanEqual
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThanEqual
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThanEqual
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint);
//
// return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
//}
//
//// equal
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type equal
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec2<valType>::bool_type(x.x == y.x, x.y == y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type equal
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec3<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type equal
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec4<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
//}
//
//// notEqual
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type notEqual
//(
// detail::tvec2<valType> const & x,
// detail::tvec2<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec2<valType>::bool_type(x.x != y.x, x.y != y.y);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type notEqual
//(
// detail::tvec3<valType> const & x,
// detail::tvec3<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec3<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
//}
//
//template <typename valType>
//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type notEqual
//(
// detail::tvec4<valType> const & x,
// detail::tvec4<valType> const & y
//)
//{
// GLM_STATIC_ASSERT(
// detail::type<valType>::is_float ||
// detail::type<valType>::is_int ||
// detail::type<valType>::is_uint ||
// detail::type<valType>::is_bool);
//
// return typename detail::tvec4<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
//}
//
//// any
//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
//{
// return x.x || x.y;
//}
//
//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
//{
// return x.x || x.y || x.z;
//}
//
//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
//{
// return x.x || x.y || x.z || x.w;
//}
//
//// all
//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
//{
// return x.x && x.y;
//}
//
//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
//{
// return x.x && x.y && x.z;
//}
//
//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
//{
// return x.x && x.y && x.z && x.w;
//}
//
//// not
//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
//(
// detail::tvec2<bool> const & v
//)
//{
// return detail::tvec2<bool>::bool_type(!v.x, !v.y);
//}
//
//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
//(
// detail::tvec3<bool> const & v
//)
//{
// return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
//}
//
//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
//(
// detail::tvec4<bool> const & v
//)
//{
// return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
//}

694
Glm/core/setup.hpp

@ -0,0 +1,694 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/setup.hpp
/// @date 2006-11-13 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_setup
#define glm_setup
///////////////////////////////////////////////////////////////////////////////////////////////////
// Version
#define GLM_VERSION 94
#define GLM_VERSION_MAJOR 0
#define GLM_VERSION_MINOR 9
#define GLM_VERSION_PATCH 4
#define GLM_VERSION_REVISION 7
///////////////////////////////////////////////////////////////////////////////////////////////////
// Platform
#define GLM_PLATFORM_UNKNOWN 0x00000000
#define GLM_PLATFORM_WINDOWS 0x00010000
#define GLM_PLATFORM_LINUX 0x00020000
#define GLM_PLATFORM_APPLE 0x00040000
//#define GLM_PLATFORM_IOS 0x00080000
#define GLM_PLATFORM_ANDROID 0x00100000
#define GLM_PLATFORM_CHROME_NACL 0x00200000
#define GLM_PLATFORM_UNIX 0x00400000
#define GLM_PLATFORM_QNXNTO 0x00800000
#define GLM_PLATFORM_WINCE 0x01000000
#ifdef GLM_FORCE_PLATFORM_UNKNOWN
# define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
#elif defined(__QNXNTO__)
# define GLM_PLATFORM GLM_PLATFORM_QNXNTO
#elif defined(__APPLE__)
# define GLM_PLATFORM GLM_PLATFORM_APPLE
#elif defined(WINCE)
# define GLM_PLATFORM GLM_PLATFORM_WINCE
#elif defined(_WIN32)
# define GLM_PLATFORM GLM_PLATFORM_WINDOWS
#elif defined(__native_client__)
# define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
#elif defined(__ANDROID__)
# define GLM_PLATFORM GLM_PLATFORM_ANDROID
#elif defined(__linux)
# define GLM_PLATFORM GLM_PLATFORM_LINUX
#elif defined(__unix)
# define GLM_PLATFORM GLM_PLATFORM_UNIX
#else
# define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
#endif//
// Report platform detection
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED))
# define GLM_MESSAGE_PLATFORM_DISPLAYED
# if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
# pragma message("GLM: QNX platform detected")
//# elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
//# pragma message("GLM: iOS platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
# pragma message("GLM: Apple platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
# pragma message("GLM: WinCE platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
# pragma message("GLM: Windows platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
# pragma message("GLM: Native Client detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
# pragma message("GLM: Android platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
# pragma message("GLM: Linux platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
# pragma message("GLM: UNIX platform detected")
# elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
# pragma message("GLM: platform unknown")
# else
# pragma message("GLM: platform not detected")
# endif
#endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Compiler
// User defines: GLM_FORCE_COMPILER_UNKNOWN
// TODO ? __llvm__
#define GLM_COMPILER_UNKNOWN 0x00000000
// Intel
#define GLM_COMPILER_INTEL 0x00100000
#define GLM_COMPILER_INTEL9 0x00100010
#define GLM_COMPILER_INTEL10_0 0x00100020
#define GLM_COMPILER_INTEL10_1 0x00100030
#define GLM_COMPILER_INTEL11_0 0x00100040
#define GLM_COMPILER_INTEL11_1 0x00100050
#define GLM_COMPILER_INTEL12_0 0x00100060
#define GLM_COMPILER_INTEL12_1 0x00100070
#define GLM_COMPILER_INTEL13_0 0x00100080
// Visual C++ defines
#define GLM_COMPILER_VC 0x01000000
#define GLM_COMPILER_VC2 0x01000010
#define GLM_COMPILER_VC4 0x01000020
#define GLM_COMPILER_VC5 0x01000030
#define GLM_COMPILER_VC6 0x01000040
#define GLM_COMPILER_VC2002 0x01000050
#define GLM_COMPILER_VC2003 0x01000060
#define GLM_COMPILER_VC2005 0x01000070
#define GLM_COMPILER_VC2008 0x01000080
#define GLM_COMPILER_VC2010 0x01000090
#define GLM_COMPILER_VC2012 0x010000A0
#define GLM_COMPILER_VC2013 0x010000B0
// GCC defines
#define GLM_COMPILER_GCC 0x02000000
#define GLM_COMPILER_GCC_LLVM 0x02000001
#define GLM_COMPILER_GCC_CLANG 0x02000002
#define GLM_COMPILER_GCC30 0x02000010
#define GLM_COMPILER_GCC31 0x02000020
#define GLM_COMPILER_GCC32 0x02000030
#define GLM_COMPILER_GCC33 0x02000040
#define GLM_COMPILER_GCC34 0x02000050
#define GLM_COMPILER_GCC35 0x02000060
#define GLM_COMPILER_GCC40 0x02000070
#define GLM_COMPILER_GCC41 0x02000080
#define GLM_COMPILER_GCC42 0x02000090
#define GLM_COMPILER_GCC43 0x020000A0
#define GLM_COMPILER_GCC44 0x020000B0
#define GLM_COMPILER_GCC45 0x020000C0
#define GLM_COMPILER_GCC46 0x020000D0
#define GLM_COMPILER_GCC47 0x020000E0
#define GLM_COMPILER_GCC48 0x020000F0
#define GLM_COMPILER_GCC49 0x02000100
// G++ command line to display defined
// echo "" | g++ -E -dM -x c++ - | sort
// Borland C++ defines. How to identify BC?
#define GLM_COMPILER_BC 0x04000000
#define GLM_COMPILER_BCB4 0x04000100
#define GLM_COMPILER_BCB5 0x04000200
#define GLM_COMPILER_BCB6 0x04000300
//#define GLM_COMPILER_BCBX 0x04000400 // What's the version value?
#define GLM_COMPILER_BCB2009 0x04000500
// CodeWarrior
#define GLM_COMPILER_CODEWARRIOR 0x08000000
// CUDA
#define GLM_COMPILER_CUDA 0x10000000
#define GLM_COMPILER_CUDA30 0x10000010
#define GLM_COMPILER_CUDA31 0x10000020
#define GLM_COMPILER_CUDA32 0x10000030
#define GLM_COMPILER_CUDA40 0x10000040
#define GLM_COMPILER_CUDA41 0x10000050
#define GLM_COMPILER_CUDA42 0x10000060
// Clang
#define GLM_COMPILER_CLANG 0x20000000
#define GLM_COMPILER_CLANG26 0x20000010
#define GLM_COMPILER_CLANG27 0x20000020
#define GLM_COMPILER_CLANG28 0x20000030
#define GLM_COMPILER_CLANG29 0x20000040
#define GLM_COMPILER_CLANG30 0x20000050
#define GLM_COMPILER_CLANG31 0x20000060
#define GLM_COMPILER_CLANG32 0x20000070
#define GLM_COMPILER_CLANG33 0x20000080
#define GLM_COMPILER_CLANG40 0x20000090
#define GLM_COMPILER_CLANG41 0x200000A0
#define GLM_COMPILER_CLANG42 0x200000B0
#define GLM_COMPILER_CLANG43 0x200000C0
// LLVM GCC
#define GLM_COMPILER_LLVM_GCC 0x40000000
// Build model
#define GLM_MODEL_32 0x00000010
#define GLM_MODEL_64 0x00000020
// Force generic C++ compiler
#ifdef GLM_FORCE_COMPILER_UNKNOWN
# define GLM_COMPILER GLM_COMPILER_UNKNOWN
#elif defined(__INTEL_COMPILER)
# if __INTEL_COMPILER == 900
# define GLM_COMPILER GLM_COMPILER_INTEL9
# elif __INTEL_COMPILER == 1000
# define GLM_COMPILER GLM_COMPILER_INTEL10_0
# elif __INTEL_COMPILER == 1010
# define GLM_COMPILER GLM_COMPILER_INTEL10_1
# elif __INTEL_COMPILER == 1100
# define GLM_COMPILER GLM_COMPILER_INTEL11_0
# elif __INTEL_COMPILER == 1110
# define GLM_COMPILER GLM_COMPILER_INTEL11_1
# elif __INTEL_COMPILER == 1200
# define GLM_COMPILER GLM_COMPILER_INTEL12_0
# elif __INTEL_COMPILER == 1210
# define GLM_COMPILER GLM_COMPILER_INTEL12_1
# elif __INTEL_COMPILER >= 1300
# define GLM_COMPILER GLM_COMPILER_INTEL13_0
# else
# define GLM_COMPILER GLM_COMPILER_INTEL
# endif
// CUDA
#elif defined(__CUDACC__)
# if CUDA_VERSION < 3000
# error "GLM requires CUDA 3.0 or higher"
# else
# define GLM_COMPILER GLM_COMPILER_CUDA
# endif
// Visual C++
#elif defined(_MSC_VER)
# if _MSC_VER < 1400
# error "GLM requires Visual C++ 2005 or higher"
# elif _MSC_VER == 1400
# define GLM_COMPILER GLM_COMPILER_VC2005
# elif _MSC_VER == 1500
# define GLM_COMPILER GLM_COMPILER_VC2008
# elif _MSC_VER == 1600
# define GLM_COMPILER GLM_COMPILER_VC2010
# elif _MSC_VER == 1700
# define GLM_COMPILER GLM_COMPILER_VC2012
# elif _MSC_VER >= 1800
# define GLM_COMPILER GLM_COMPILER_VC2013
# else//_MSC_VER
# define GLM_COMPILER GLM_COMPILER_VC
# endif//_MSC_VER
// Clang
#elif defined(__clang__)
# if (__clang_major__ <= 1) || ((__clang_major__ == 2) && (__clang_minor__ < 6))
# error "GLM requires Clang 2.6 or higher"
# elif(__clang_major__ == 2) && (__clang_minor__ == 6)
# define GLM_COMPILER GLM_COMPILER_CLANG26
# elif(__clang_major__ == 2) && (__clang_minor__ == 7)
# define GLM_COMPILER GLM_COMPILER_CLANG27
# elif(__clang_major__ == 2) && (__clang_minor__ == 8)
# define GLM_COMPILER GLM_COMPILER_CLANG28
# elif(__clang_major__ == 2) && (__clang_minor__ == 9)
# define GLM_COMPILER GLM_COMPILER_CLANG29
# elif(__clang_major__ == 3) && (__clang_minor__ == 0)
# define GLM_COMPILER GLM_COMPILER_CLANG30
# elif(__clang_major__ == 3) && (__clang_minor__ == 1)
# define GLM_COMPILER GLM_COMPILER_CLANG31
# elif(__clang_major__ == 3) && (__clang_minor__ == 2)
# define GLM_COMPILER GLM_COMPILER_CLANG32
# elif(__clang_major__ == 3) && (__clang_minor__ == 3)
# define GLM_COMPILER GLM_COMPILER_CLANG33
# elif(__clang_major__ == 4) && (__clang_minor__ == 0)
# define GLM_COMPILER GLM_COMPILER_CLANG40
# elif(__clang_major__ == 4) && (__clang_minor__ == 1)
# define GLM_COMPILER GLM_COMPILER_CLANG41
# elif(__clang_major__ == 4) && (__clang_minor__ == 2)
# define GLM_COMPILER GLM_COMPILER_CLANG42
# elif(__clang_major__ == 4) && (__clang_minor__ >= 3)
# define GLM_COMPILER GLM_COMPILER_CLANG43
# elif(__clang_major__ > 4)
# define GLM_COMPILER GLM_COMPILER_CLANG43
# else
# define GLM_COMPILER GLM_COMPILER_CLANG
# endif
// G++
#elif(defined(__GNUC__) || defined(__MINGW32__))// || defined(__llvm__) || defined(__clang__)
# if (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
# define GLM_COMPILER GLM_COMPILER_GCC32
# elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 3)
# define GLM_COMPILER GLM_COMPILER_GCC33
# elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
# define GLM_COMPILER GLM_COMPILER_GCC34
# elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 5)
# define GLM_COMPILER GLM_COMPILER_GCC35
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 0)
# define GLM_COMPILER (GLM_COMPILER_GCC40)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 1)
# define GLM_COMPILER (GLM_COMPILER_GCC41)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
# define GLM_COMPILER (GLM_COMPILER_GCC42)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
# define GLM_COMPILER (GLM_COMPILER_GCC43)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
# define GLM_COMPILER (GLM_COMPILER_GCC44)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
# define GLM_COMPILER (GLM_COMPILER_GCC45)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
# define GLM_COMPILER (GLM_COMPILER_GCC46)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
# define GLM_COMPILER (GLM_COMPILER_GCC47)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
# define GLM_COMPILER (GLM_COMPILER_GCC48)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
# define GLM_COMPILER (GLM_COMPILER_GCC49)
# elif (__GNUC__ > 4 )
# define GLM_COMPILER (GLM_COMPILER_GCC49)
# else
# define GLM_COMPILER (GLM_COMPILER_GCC)
# endif
// Borland C++
#elif defined(_BORLANDC_)
# define GLM_COMPILER GLM_COMPILER_BC
// Codewarrior
#elif defined(__MWERKS__)
# define GLM_COMPILER GLM_COMPILER_CODEWARRIOR
#else
# define GLM_COMPILER GLM_COMPILER_UNKNOWN
#endif
#ifndef GLM_COMPILER
#error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
#endif//GLM_COMPILER
// Report compiler detection
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED))
# define GLM_MESSAGE_COMPILER_DISPLAYED
# if(GLM_COMPILER & GLM_COMPILER_CUDA)
# pragma message("GLM: CUDA compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_VC)
# pragma message("GLM: Visual C++ compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_CLANG)
# pragma message("GLM: Clang compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
# pragma message("GLM: LLVM GCC compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_GCC)
# if(GLM_COMPILER == GLM_COMPILER_GCC_LLVM)
# pragma message("GLM: LLVM GCC compiler detected")
# elif(GLM_COMPILER == GLM_COMPILER_GCC_CLANG)
# pragma message("GLM: CLANG compiler detected")
# else
# pragma message("GLM: GCC compiler detected")
# endif
# elif(GLM_COMPILER & GLM_COMPILER_BC)
# pragma message("GLM: Borland compiler detected but not supported")
# elif(GLM_COMPILER & GLM_COMPILER_CODEWARRIOR)
# pragma message("GLM: Codewarrior compiler detected but not supported")
# else
# pragma message("GLM: Compiler not detected")
# endif
#endif//GLM_MESSAGE
/////////////////
// Build model //
#if(defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__))
# define GLM_MODEL GLM_MODEL_64
#elif(defined(__i386__) || defined(__ppc__))
# define GLM_MODEL GLM_MODEL_32
#else
# define GLM_MODEL GLM_MODEL_32
#endif//
#if(!defined(GLM_MODEL) && GLM_COMPILER != 0)
# error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
#endif//GLM_MODEL
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED))
# define GLM_MESSAGE_MODEL_DISPLAYED
# if(GLM_MODEL == GLM_MODEL_64)
# pragma message("GLM: 64 bits model")
# elif(GLM_MODEL == GLM_MODEL_32)
# pragma message("GLM: 32 bits model")
# endif//GLM_MODEL
#endif//GLM_MESSAGE
/////////////////
// C++ Version //
// User defines: GLM_FORCE_CXX98
#define GLM_LANG_CXX (0 << 0)
#define GLM_LANG_CXX98 ((1 << 1) | GLM_LANG_CXX)
#define GLM_LANG_CXX03 ((1 << 2) | GLM_LANG_CXX98)
#define GLM_LANG_CXX0X ((1 << 3) | GLM_LANG_CXX03)
#define GLM_LANG_CXX11 ((1 << 4) | GLM_LANG_CXX0X)
#define GLM_LANG_CXXMS (1 << 5)
#define GLM_LANG_CXXGNU (1 << 6)
#if(defined(GLM_FORCE_CXX11))
# define GLM_LANG GLM_LANG_CXX11
#elif(defined(GLM_FORCE_CXX03))
# define GLM_LANG GLM_LANG_CXX03
#elif(defined(GLM_FORCE_CXX98))
# define GLM_LANG GLM_LANG_CXX98
#else
# if(__cplusplus >= 201103L)
# define GLM_LANG GLM_LANG_CXX11
# elif((GLM_COMPILER & GLM_COMPILER_CLANG) == GLM_COMPILER_CLANG)
# if(GLM_PLATFORM == GLM_PLATFORM_APPLE)
# define GLM_DETAIL_MAJOR 1
# else
# define GLM_DETAIL_MAJOR 0
# endif
# if(__clang_major__ < (2 + GLM_DETAIL_MAJOR))
# define GLM_LANG GLM_LANG_CXX
# elif(__has_feature(cxx_auto_type))
# define GLM_LANG GLM_LANG_CXX0X
# else
# define GLM_LANG GLM_LANG_CXX98
# endif
# elif((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define GLM_LANG GLM_LANG_CXX0X
# else
# define GLM_LANG GLM_LANG_CXX98
# endif
# elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS))
# define GLM_LANG GLM_LANG_CXXMS
# elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS))
# if(GLM_COMPILER >= GLM_COMPILER_VC2010)
# define GLM_LANG GLM_LANG_CXX0X
# else
# define GLM_LANG GLM_LANG_CXX98
# endif
# elif(__cplusplus >= 199711L)
# define GLM_LANG GLM_LANG_CXX98
# else
# define GLM_LANG GLM_LANG_CXX
# endif
#endif
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED))
# define GLM_MESSAGE_LANG_DISPLAYED
# if(GLM_LANG == GLM_LANG_CXX98)
# pragma message("GLM: C++98")
# elif(GLM_LANG == GLM_LANG_CXX03)
# pragma message("GLM: C++03")
# elif(GLM_LANG == GLM_LANG_CXX0X)
# pragma message("GLM: C++0x")
# elif(GLM_LANG == GLM_LANG_CXX11)
# pragma message("GLM: C++11")
# elif(GLM_LANG == GLM_LANG_CXXGNU)
# pragma message("GLM: C++ with GNU language extensions")
# elif(GLM_LANG == GLM_LANG_CXXMS)
# pragma message("GLM: C++ with VC language extensions")
# else
# pragma message("GLM: C++ language undetected")
# endif//GLM_MODEL
#endif//GLM_MESSAGE
/////////////////
// Platform
// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_AVX
#define GLM_ARCH_PURE 0x0000
#define GLM_ARCH_SSE2 0x0001
#define GLM_ARCH_SSE3 0x0002// | GLM_ARCH_SSE2
#define GLM_ARCH_SSE4 0x0004// | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
#define GLM_ARCH_AVX 0x0008// | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
#define GLM_ARCH_AVX2 0x0010// | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
#if(defined(GLM_FORCE_PURE))
# define GLM_ARCH GLM_ARCH_PURE
#elif(defined(GLM_FORCE_AVX2))
# define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
#elif(defined(GLM_FORCE_AVX))
# define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
#elif(defined(GLM_FORCE_SSE4))
# define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
#elif(defined(GLM_FORCE_SSE3))
# define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
#elif(defined(GLM_FORCE_SSE2))
# define GLM_ARCH (GLM_ARCH_SSE2)
#elif((GLM_COMPILER & GLM_COMPILER_VC) && (defined(_M_IX86) || defined(_M_X64)))
# if(GLM_PLATFORM == GLM_PLATFORM_WINCE)
# define GLM_ARCH GLM_ARCH_PURE
# elif(defined(_M_CEE_PURE))
# define GLM_ARCH GLM_ARCH_PURE
/* TODO: Explore auto detection of instruction set support
# elif(defined(_M_IX86_FP))
# if(_M_IX86_FP >= 3)
# define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
# elif(_M_IX86_FP >= 2)
# define GLM_ARCH (GLM_ARCH_SSE2)
# else
# define GLM_ARCH GLM_ARCH_PURE
# endif
*/
# elif(GLM_COMPILER >= GLM_COMPILER_VC2012)
# define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
# elif(GLM_COMPILER >= GLM_COMPILER_VC2010)
# if(_MSC_FULL_VER >= 160031118) //160031118: VC2010 SP1 beta full version
# define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)//GLM_ARCH_AVX (Require SP1)
# else
# define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
# endif
# elif(GLM_COMPILER >= GLM_COMPILER_VC2008)
# define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
# elif(GLM_COMPILER >= GLM_COMPILER_VC2005)
# define GLM_ARCH GLM_ARCH_SSE2
# else
# define GLM_ARCH GLM_ARCH_PURE
# endif
#elif((GLM_PLATFORM & GLM_PLATFORM_APPLE) && (GLM_COMPILER & GLM_COMPILER_GCC))
# define GLM_ARCH GLM_ARCH_PURE
#elif(((GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))) || (GLM_COMPILER & GLM_COMPILER_LLVM_GCC))
# define GLM_ARCH (GLM_ARCH_PURE \
| (defined(__AVX2__) ? GLM_ARCH_AVX2 : 0) \
| (defined(__AVX__) ? GLM_ARCH_AVX : 0) \
| (defined(__SSE4__) ? GLM_ARCH_SSE4 : 0) \
| (defined(__SSE3__) ? GLM_ARCH_SSE3 : 0) \
| (defined(__SSE2__) ? GLM_ARCH_SSE2 : 0))
#else
# define GLM_ARCH GLM_ARCH_PURE
#endif
// With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is
// that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems.
// To fix, we just explicitly include intrin.h here.
#if defined(__MINGW32__) && (GLM_ARCH != GLM_ARCH_PURE)
# include <intrin.h>
#endif
//#if(GLM_ARCH != GLM_ARCH_PURE)
#if(GLM_ARCH & GLM_ARCH_AVX2)
# include <immintrin.h>
#endif//GLM_ARCH
#if(GLM_ARCH & GLM_ARCH_AVX)
# include <immintrin.h>
#endif//GLM_ARCH
#if(GLM_ARCH & GLM_ARCH_SSE4)
# include <smmintrin.h>
#endif//GLM_ARCH
#if(GLM_ARCH & GLM_ARCH_SSE3)
# include <pmmintrin.h>
#endif//GLM_ARCH
#if(GLM_ARCH & GLM_ARCH_SSE2)
# include <emmintrin.h>
#endif//GLM_ARCH
//#endif//(GLM_ARCH != GLM_ARCH_PURE)
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED))
# define GLM_MESSAGE_ARCH_DISPLAYED
# if(GLM_ARCH == GLM_ARCH_PURE)
# pragma message("GLM: Platform independent")
# elif(GLM_ARCH & GLM_ARCH_SSE2)
# pragma message("GLM: SSE2 instruction set")
# elif(GLM_ARCH & GLM_ARCH_SSE3)
# pragma message("GLM: SSE3 instruction set")
# elif(GLM_ARCH & GLM_ARCH_SSE4)
# pragma message("GLM: SSE4 instruction set")
# elif(GLM_ARCH & GLM_ARCH_AVX)
# pragma message("GLM: AVX instruction set")
# elif(GLM_ARCH & GLM_ARCH_AVX2)
# pragma message("GLM: AVX2 instruction set")
# endif//GLM_ARCH
#endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Support check macros
#define GLM_SUPPORT_ANONYMOUS_UNION() \
((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98)
//#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() <backslash>
// (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))
#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS)) || ((GLM_LANG == GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
#define GLM_SUPPORT_SWIZZLE_OPERATOR() \
(/*defined(GLM_SWIZZLE) && */GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Components
//#define GLM_FORCE_ONLY_XYZW
#define GLM_COMPONENT_ONLY_XYZW 0 // To disable multiple vector component names access.
#define GLM_COMPONENT_CXX98 1 //
#define GLM_COMPONENT_CXX11 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
# define GLM_COMPONENT GLM_COMPONENT_CXX11
#elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
# define GLM_COMPONENT GLM_COMPONENT_CXX98
#else
# define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
#endif
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
# define GLM_MESSAGE_COMPONENT_DISPLAYED
# if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
# pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
# elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
# pragma message("GLM: x,y,z,w component names for all vector types")
# elif(GLM_COMPONENT == GLM_COMPONENT_CXX11)
# pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
# else
# error "GLM: GLM_COMPONENT value unknown"
# endif//GLM_MESSAGE_COMPONENT_DISPLAYED
#endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Radians
//#define GLM_FORCE_RADIANS
///////////////////////////////////////////////////////////////////////////////////////////////////
// Static assert
#if(GLM_LANG == GLM_LANG_CXX0X)
# define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
#elif(defined(BOOST_STATIC_ASSERT))
# define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
#elif(GLM_COMPILER & GLM_COMPILER_VC)
# 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
///////////////////////////////////////////////////////////////////////////////////////////////////
// Qualifiers
// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
#if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
# define GLM_CUDA_FUNC_DEF __device__ __host__
# define GLM_CUDA_FUNC_DECL __device__ __host__
#else
# define GLM_CUDA_FUNC_DEF
# define GLM_CUDA_FUNC_DECL
#endif
#if GLM_COMPILER & GLM_COMPILER_GCC
# define GLM_VAR_USED __attribute__ ((unused))
#else
# define GLM_VAR_USED
#endif
#if(defined(GLM_FORCE_INLINE))
# if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
# define GLM_INLINE __forceinline
# elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
# define GLM_INLINE __attribute__((always_inline))
# elif(GLM_COMPILER & GLM_COMPILER_CLANG)
# define GLM_INLINE __attribute__((always_inline))
# else
# define GLM_INLINE inline
# endif//GLM_COMPILER
#else
# define GLM_INLINE inline
#endif//defined(GLM_FORCE_INLINE)
#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Swizzle operators
// User defines: GLM_SWIZZLE
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
# define GLM_MESSAGE_SWIZZLE_DISPLAYED
# if(GLM_SUPPORT_SWIZZLE_OPERATOR())
# pragma message("GLM: Swizzling operators enabled")
# elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
# pragma message("GLM: Swizzling operators supported through swizzling functions")
# else
# pragma message("GLM: Swizzling operators disabled")
# endif
#endif//GLM_MESSAGE
#endif//glm_setup

341
Glm/core/type.hpp

@ -0,0 +1,341 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type.hpp
/// @date 2008-01-08 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type
#define glm_core_type
#include "type_half.hpp"
#include "type_float.hpp"
#include "type_int.hpp"
#include "type_gentype.hpp"
#include "type_vec1.hpp"
#include "type_vec2.hpp"
#include "type_vec3.hpp"
#include "type_vec4.hpp"
#include "type_mat2x2.hpp"
#include "type_mat2x3.hpp"
#include "type_mat2x4.hpp"
#include "type_mat3x2.hpp"
#include "type_mat3x3.hpp"
#include "type_mat3x4.hpp"
#include "type_mat4x2.hpp"
#include "type_mat4x3.hpp"
#include "type_mat4x4.hpp"
namespace glm
{
/// @addtogroup core_types
/// @{
//////////////////////////
// Float definition
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef highp_vec2 vec2;
typedef highp_vec3 vec3;
typedef highp_vec4 vec4;
typedef highp_mat2x2 mat2x2;
typedef highp_mat2x3 mat2x3;
typedef highp_mat2x4 mat2x4;
typedef highp_mat3x2 mat3x2;
typedef highp_mat3x3 mat3x3;
typedef highp_mat3x4 mat3x4;
typedef highp_mat4x2 mat4x2;
typedef highp_mat4x3 mat4x3;
typedef highp_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef mediump_vec2 vec2;
typedef mediump_vec3 vec3;
typedef mediump_vec4 vec4;
typedef mediump_mat2x2 mat2x2;
typedef mediump_mat2x3 mat2x3;
typedef mediump_mat2x4 mat2x4;
typedef mediump_mat3x2 mat3x2;
typedef mediump_mat3x3 mat3x3;
typedef mediump_mat3x4 mat3x4;
typedef mediump_mat4x2 mat4x2;
typedef mediump_mat4x3 mat4x3;
typedef mediump_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_vec2 vec2;
typedef lowp_vec3 vec3;
typedef lowp_vec4 vec4;
typedef lowp_mat2x2 mat2x2;
typedef lowp_mat2x3 mat2x3;
typedef lowp_mat2x4 mat2x4;
typedef lowp_mat3x2 mat3x2;
typedef lowp_mat3x3 mat3x3;
typedef lowp_mat3x4 mat3x4;
typedef lowp_mat4x2 mat4x2;
typedef lowp_mat4x3 mat4x3;
typedef lowp_mat4x4 mat4x4;
#else
/// 2 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec2 vec2;
//! 3 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec3 vec3;
//! 4 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec4 vec4;
//! 2 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x2 mat2x2;
//! 2 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x3 mat2x3;
//! 2 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x4 mat2x4;
//! 3 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x2 mat3x2;
//! 3 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x3 mat3x3;
//! 3 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x4 mat3x4;
//! 4 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x2 mat4x2;
//! 4 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x3 mat4x3;
//! 4 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x4 mat4x4;
#endif//GLM_PRECISION
//! 2 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat2x2 mat2;
//! 3 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat3x3 mat3;
//! 4 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat4x4 mat4;
//////////////////////////
// Signed integer definition
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_ivec2 ivec2;
typedef highp_ivec3 ivec3;
typedef highp_ivec4 ivec4;
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef mediump_ivec2 ivec2;
typedef mediump_ivec3 ivec3;
typedef mediump_ivec4 ivec4;
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_ivec2 ivec2;
typedef lowp_ivec3 ivec3;
typedef lowp_ivec4 ivec4;
#else
//! 2 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec2 ivec2;
//! 3 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec3 ivec3;
//! 4 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec4 ivec4;
#endif//GLM_PRECISION
//////////////////////////
// Unsigned integer definition
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef highp_uvec2 uvec2;
typedef highp_uvec3 uvec3;
typedef highp_uvec4 uvec4;
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef mediump_uvec2 uvec2;
typedef mediump_uvec3 uvec3;
typedef mediump_uvec4 uvec4;
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_uvec2 uvec2;
typedef lowp_uvec3 uvec3;
typedef lowp_uvec4 uvec4;
#else
//! 2 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec2 uvec2;
//! 3 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec3 uvec3;
//! 4 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec4 uvec4;
#endif//GLM_PRECISION
//////////////////////////
// Boolean definition
//! 2 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec2<bool> bvec2;
//! 3 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec3<bool> bvec3;
//! 4 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec4<bool> bvec4;
//////////////////////////
// Double definition
//! Vector of 2 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec2<double> dvec2;
//! Vector of 3 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec3<double> dvec3;
//! Vector of 4 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec4<double> dvec4;
//! 2 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat2x2<double> dmat2;
//! 3 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat3x3<double> dmat3;
//! 4 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat4x4<double> dmat4;
//! 2 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat2x2<double> dmat2x2;
//! 2 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat2x3<double> dmat2x3;
//! 2 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat2x4<double> dmat2x4;
//! 3 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat3x2<double> dmat3x2;
//! 3 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat3x3<double> dmat3x3;
//! 3 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat3x4<double> dmat3x4;
//! 4 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat4x2<double> dmat4x2;
//! 4 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat4x3<double> dmat4x3;
//! 4 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef detail::tmat4x4<double> dmat4x4;
/// @}
}//namespace glm
#endif//glm_core_type

84
Glm/core/type_float.hpp

@ -0,0 +1,84 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_float.hpp
/// @date 2008-08-22 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_float
#define glm_core_type_float
#include "type_half.hpp"
#include "setup.hpp"
namespace glm
{
#ifdef GLM_USE_HALF_SCALAR
typedef detail::half lowp_float_t;
#else//GLM_USE_HALF_SCALAR
typedef float lowp_float_t;
#endif//GLM_USE_HALF_SCALAR
typedef float mediump_float_t;
typedef double highp_float_t;
/// @addtogroup core_precision
/// @{
/// Low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef lowp_float_t lowp_float;
/// Medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mediump_float_t mediump_float;
/// High precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef highp_float_t highp_float;
#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef mediump_float float_t;
#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef highp_float float_t;
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef mediump_float float_t;
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_float float_t;
#else
# error "GLM error: multiple default precision requested for floating-point types"
#endif
/// @}
}//namespace glm
#endif//glm_core_type_float

169
Glm/core/type_gentype.hpp

@ -0,0 +1,169 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_gentype.hpp
/// @date 2008-10-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_gentype
#define glm_core_type_gentype
#include "type_size.hpp"
namespace glm
{
enum profile
{
nice,
fast,
simd
};
namespace detail
{
template
<
typename VALTYPE,
template <typename> class TYPE
>
struct genType
{
public:
enum ctor{null};
typedef VALTYPE value_type;
typedef VALTYPE & value_reference;
typedef VALTYPE * value_pointer;
typedef VALTYPE const * value_const_pointer;
typedef TYPE<bool> bool_type;
typedef sizeType size_type;
static bool is_vector();
static bool is_matrix();
typedef TYPE<VALTYPE> type;
typedef TYPE<VALTYPE> * pointer;
typedef TYPE<VALTYPE> const * const_pointer;
typedef TYPE<VALTYPE> const * const const_pointer_const;
typedef TYPE<VALTYPE> * const pointer_const;
typedef TYPE<VALTYPE> & reference;
typedef TYPE<VALTYPE> const & const_reference;
typedef TYPE<VALTYPE> const & param_type;
//////////////////////////////////////
// Address (Implementation details)
value_const_pointer value_address() const{return value_pointer(this);}
value_pointer value_address(){return value_pointer(this);}
//protected:
// enum kind
// {
// GEN_TYPE,
// VEC_TYPE,
// MAT_TYPE
// };
// typedef typename TYPE::kind kind;
};
template
<
typename VALTYPE,
template <typename> class TYPE
>
bool genType<VALTYPE, TYPE>::is_vector()
{
return true;
}
/*
template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
class base
{
public:
//////////////////////////////////////
// Traits
typedef sizeType size_type;
typedef valTypeT value_type;
typedef base<value_type, colT, rowT> class_type;
typedef base<bool, colT, rowT> bool_type;
typedef base<value_type, rowT, 1> col_type;
typedef base<value_type, colT, 1> row_type;
typedef base<value_type, rowT, colT> transpose_type;
static size_type col_size();
static size_type row_size();
static size_type value_size();
static bool is_scalar();
static bool is_vector();
static bool is_matrix();
private:
// Data
col_type value[colT];
public:
//////////////////////////////////////
// Constructors
base();
base(class_type const & m);
explicit base(value_type const & x);
explicit base(value_type const * const x);
explicit base(col_type const * const x);
//////////////////////////////////////
// Conversions
template <typename vU, uint cU, uint rU, profile pU>
explicit base(base<vU, cU, rU, pU> const & m);
//////////////////////////////////////
// Accesses
col_type& operator[](size_type i);
col_type const & operator[](size_type i) const;
//////////////////////////////////////
// Unary updatable operators
class_type& operator= (class_type const & x);
class_type& operator+= (value_type const & x);
class_type& operator+= (class_type const & x);
class_type& operator-= (value_type const & x);
class_type& operator-= (class_type const & x);
class_type& operator*= (value_type const & x);
class_type& operator*= (class_type const & x);
class_type& operator/= (value_type const & x);
class_type& operator/= (class_type const & x);
class_type& operator++ ();
class_type& operator-- ();
};
*/
}//namespace detail
}//namespace glm
//#include "type_gentype.inl"
#endif//glm_core_type_gentype

366
Glm/core/type_gentype.inl

@ -0,0 +1,366 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_gentype.inl
/// @date 2008-10-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail{
/////////////////////////////////
// Static functions
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
{
return cT;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
{
return rT;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
{
return rT * cT;
}
template <typename vT, uint cT, uint rT, profile pT>
bool base<vT, cT, rT, pT>::is_scalar()
{
return rT == 1 && cT == 1;
}
template <typename vT, uint cT, uint rT, profile pT>
bool base<vT, cT, rT, pT>::is_vector()
{
return rT == 1;
}
template <typename vT, uint cT, uint rT, profile pT>
bool base<vT, cT, rT, pT>::is_matrix()
{
return rT != 1;
}
/////////////////////////////////
// Constructor
template <typename vT, uint cT, uint rT, profile pT>
base<vT, cT, rT, pT>::base()
{
memset(&this->value, 0, cT * rT * sizeof(vT));
}
template <typename vT, uint cT, uint rT, profile pT>
base<vT, cT, rT, pT>::base
(
typename base<vT, cT, rT, pT>::class_type const & m
)
{
for
(
typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
this->value[i] = m[i];
}
}
template <typename vT, uint cT, uint rT, profile pT>
base<vT, cT, rT, pT>::base
(
typename base<vT, cT, rT, pT>::value_type const & x
)
{
if(rT == 1) // vector
{
for
(
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
this->value[i][rT] = x;
}
}
else // matrix
{
memset(&this->value, 0, cT * rT * sizeof(vT));
typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
for
(
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < stop;
++i
)
{
this->value[i][i] = x;
}
}
}
template <typename vT, uint cT, uint rT, profile pT>
base<vT, cT, rT, pT>::base
(
typename base<vT, cT, rT, pT>::value_type const * const x
)
{
memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
}
template <typename vT, uint cT, uint rT, profile pT>
base<vT, cT, rT, pT>::base
(
typename base<vT, cT, rT, pT>::col_type const * const x
)
{
for
(
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
this->value[i] = x[i];
}
}
template <typename vT, uint cT, uint rT, profile pT>
template <typename vU, uint cU, uint rU, profile pU>
base<vT, cT, rT, pT>::base
(
base<vU, cU, rU, pU> const & m
)
{
for
(
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
this->value[i] = base<vT, cT, rT, pT>(m[i]);
}
}
//////////////////////////////////////
// Accesses
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
(
typename base<vT, cT, rT, pT>::size_type i
)
{
return this->value[i];
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
(
typename base<vT, cT, rT, pT>::size_type i
) const
{
return this->value[i];
}
//////////////////////////////////////
// Unary updatable operators
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator=
(
typename base<vT, cT, rT, pT>::class_type const & x
)
{
memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+=
(
typename base<vT, cT, rT, pT>::value_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] += x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+=
(
typename base<vT, cT, rT, pT>::class_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] += x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-=
(
typename base<vT, cT, rT, pT>::value_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] -= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-=
(
typename base<vT, cT, rT, pT>::class_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] -= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*=
(
typename base<vT, cT, rT, pT>::value_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] *= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*=
(
typename base<vT, cT, rT, pT>::class_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] *= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/=
(
typename base<vT, cT, rT, pT>::value_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] /= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/=
(
typename base<vT, cT, rT, pT>::class_type const & x
)
{
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] /= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
{
typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
++this->value[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
{
typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
--this->value[j][i];
return *this;
}
} //namespace detail
} //namespace glm

118
Glm/core/type_half.hpp

@ -0,0 +1,118 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_half.hpp
/// @date 2008-08-17 / 2011-09-20
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_half
#define glm_core_type_half
#include <cstdlib>
namespace glm{
namespace detail
{
typedef short hdata;
GLM_FUNC_DECL float toFloat32(hdata value);
GLM_FUNC_DECL hdata toFloat16(float const & value);
class half
{
public:
// Constructors
GLM_FUNC_DECL half();
GLM_FUNC_DECL half(half const & s);
template <typename U>
GLM_FUNC_DECL explicit half(U const & s);
// Cast
//template <typename U>
//GLM_FUNC_DECL operator U() const;
GLM_FUNC_DECL operator float() const;
// Unary updatable operators
GLM_FUNC_DECL half& operator= (half const & s);
GLM_FUNC_DECL half& operator+=(half const & s);
GLM_FUNC_DECL half& operator-=(half const & s);
GLM_FUNC_DECL half& operator*=(half const & s);
GLM_FUNC_DECL half& operator/=(half const & s);
GLM_FUNC_DECL half& operator++();
GLM_FUNC_DECL half& operator--();
GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
GLM_FUNC_DECL hdata _data() const{return data;}
private:
hdata data;
};
GLM_FUNC_DECL half operator+ (half const & s1, half const & s2);
GLM_FUNC_DECL half operator- (half const & s1, half const & s2);
GLM_FUNC_DECL half operator* (half const & s1, half const & s2);
GLM_FUNC_DECL half operator/ (half const & s1, half const & s2);
// Unary constant operators
GLM_FUNC_DECL half operator- (half const & s);
GLM_FUNC_DECL half operator-- (half const & s, int);
GLM_FUNC_DECL half operator++ (half const & s, int);
GLM_FUNC_DECL bool operator==(
detail::half const & x,
detail::half const & y);
GLM_FUNC_DECL bool operator!=(
detail::half const & x,
detail::half const & y);
GLM_FUNC_DECL bool operator<(
detail::half const & x,
detail::half const & y);
GLM_FUNC_DECL bool operator<=(
detail::half const & x,
detail::half const & y);
GLM_FUNC_DECL bool operator>(
detail::half const & x,
detail::half const & y);
GLM_FUNC_DECL bool operator>=(
detail::half const & x,
detail::half const & y);
}//namespace detail
}//namespace glm
#include "type_half.inl"
#endif//glm_core_type_half

421
Glm/core/type_half.inl

@ -0,0 +1,421 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
///
/// This half implementation is based on OpenEXR which is Copyright (c) 2002,
/// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_half.inl
/// @date 2008-08-17 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include "_detail.hpp"
namespace glm{
namespace detail
{
GLM_FUNC_QUALIFIER float overflow()
{
volatile float f = 1e10;
for(int i = 0; i < 10; ++i)
f *= f; // this will overflow before
// the for­loop terminates
return f;
}
GLM_FUNC_QUALIFIER float toFloat32(hdata value)
{
int s = (value >> 15) & 0x00000001;
int e = (value >> 10) & 0x0000001f;
int m = value & 0x000003ff;
if(e == 0)
{
if(m == 0)
{
//
// Plus or minus zero
//
detail::uif result;
result.i = (unsigned int)(s << 31);
return result.f;
}
else
{
//
// Denormalized number -- renormalize it
//
while(!(m & 0x00000400))
{
m <<= 1;
e -= 1;
}
e += 1;
m &= ~0x00000400;
}
}
else if(e == 31)
{
if(m == 0)
{
//
// Positive or negative infinity
//
uif result;
result.i = (unsigned int)((s << 31) | 0x7f800000);
return result.f;
}
else
{
//
// Nan -- preserve sign and significand bits
//
uif result;
result.i = (unsigned int)((s << 31) | 0x7f800000 | (m << 13));
return result.f;
}
}
//
// Normalized number
//
e = e + (127 - 15);
m = m << 13;
//
// Assemble s, e and m.
//
uif Result;
Result.i = (unsigned int)((s << 31) | (e << 23) | m);
return Result.f;
}
GLM_FUNC_QUALIFIER hdata toFloat16(float const & f)
{
uif Entry;
Entry.f = f;
int i = (int)Entry.i;
//
// Our floating point number, f, is represented by the bit
// pattern in integer i. Disassemble that bit pattern into
// the sign, s, the exponent, e, and the significand, m.
// Shift s into the position where it will go in in the
// resulting half number.
// Adjust e, accounting for the different exponent bias
// of float and half (127 versus 15).
//
int s = (i >> 16) & 0x00008000;
int e = ((i >> 23) & 0x000000ff) - (127 - 15);
int m = i & 0x007fffff;
//
// Now reassemble s, e and m into a half:
//
if(e <= 0)
{
if(e < -10)
{
//
// E is less than -10. The absolute value of f is
// less than half_MIN (f may be a small normalized
// float, a denormalized float or a zero).
//
// We convert f to a half zero.
//
return hdata(s);
}
//
// E is between -10 and 0. F is a normalized float,
// whose magnitude is less than __half_NRM_MIN.
//
// We convert f to a denormalized half.
//
m = (m | 0x00800000) >> (1 - e);
//
// Round to nearest, round "0.5" up.
//
// Rounding may cause the significand to overflow and make
// our number normalized. Because of the way a half's bits
// are laid out, we don't have to treat this case separately;
// the code below will handle it correctly.
//
if(m & 0x00001000)
m += 0x00002000;
//
// Assemble the half from s, e (zero) and m.
//
return hdata(s | (m >> 13));
}
else if(e == 0xff - (127 - 15))
{
if(m == 0)
{
//
// F is an infinity; convert f to a half
// infinity with the same sign as f.
//
return hdata(s | 0x7c00);
}
else
{
//
// F is a NAN; we produce a half NAN that preserves
// the sign bit and the 10 leftmost bits of the
// significand of f, with one exception: If the 10
// leftmost bits are all zero, the NAN would turn
// into an infinity, so we have to set at least one
// bit in the significand.
//
m >>= 13;
return hdata(s | 0x7c00 | m | (m == 0));
}
}
else
{
//
// E is greater than zero. F is a normalized float.
// We try to convert f to a normalized half.
//
//
// Round to nearest, round "0.5" up
//
if(m & 0x00001000)
{
m += 0x00002000;
if(m & 0x00800000)
{
m = 0; // overflow in significand,
e += 1; // adjust exponent
}
}
//
// Handle exponent overflow
//
if (e > 30)
{
overflow(); // Cause a hardware floating point overflow;
return hdata(s | 0x7c00);
// if this returns, the half becomes an
} // infinity with the same sign as f.
//
// Assemble the half from s, e and m.
//
return hdata(s | (e << 10) | (m >> 13));
}
}
GLM_FUNC_QUALIFIER half::half() :
data(0)
{}
GLM_FUNC_QUALIFIER half::half(half const & s) :
data(s.data)
{}
template <typename U>
GLM_FUNC_QUALIFIER half::half(U const & s) :
data(toFloat16(float(s)))
{}
/*
template <typename U>
GLM_FUNC_QUALIFIER half::operator U() const
{
return static_cast<U>(toFloat32(this->data));
}
*/
GLM_FUNC_QUALIFIER half::operator float() const
{
return toFloat32(this->data);
}
// Unary updatable operators
GLM_FUNC_QUALIFIER half& half::operator= (half const & s)
{
data = s.data;
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator+=(half const & s)
{
data = toFloat16(toFloat32(data) + toFloat32(s.data));
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator-=(half const & s)
{
data = toFloat16(toFloat32(data) - toFloat32(s.data));
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator*=(half const & s)
{
data = toFloat16(toFloat32(data) * toFloat32(s.data));
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator/=(half const & s)
{
data = toFloat16(toFloat32(data) / toFloat32(s.data));
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator++()
{
float Casted = toFloat32(data);
this->data = toFloat16(++Casted);
return *this;
}
GLM_FUNC_QUALIFIER half& half::operator--()
{
float Casted = toFloat32(data);
this->data = toFloat16(--Casted);
return *this;
}
//////////////////////////////////////
// Binary arithmetic operators
GLM_FUNC_QUALIFIER detail::half operator+ (detail::half const & s1, detail::half const & s2)
{
return detail::half(float(s1) + float(s2));
}
GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s1, detail::half const & s2)
{
return detail::half(float(s1) - float(s2));
}
GLM_FUNC_QUALIFIER detail::half operator* (detail::half const & s1, detail::half const & s2)
{
return detail::half(float(s1) * float(s2));
}
GLM_FUNC_QUALIFIER detail::half operator/ (detail::half const & s1, detail::half const & s2)
{
return detail::half(float(s1) / float(s2));
}
// Unary constant operators
GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s)
{
return detail::half(-float(s));
}
GLM_FUNC_QUALIFIER detail::half operator-- (detail::half const & s, int)
{
return detail::half(float(s) - 1.0f);
}
GLM_FUNC_QUALIFIER detail::half operator++ (detail::half const & s, int)
{
return detail::half(float(s) + 1.0f);
}
GLM_FUNC_QUALIFIER bool operator==
(
detail::half const & x,
detail::half const & y
)
{
return x._data() == y._data();
}
GLM_FUNC_QUALIFIER bool operator!=
(
detail::half const & x,
detail::half const & y
)
{
return x._data() != y._data();
}
GLM_FUNC_QUALIFIER bool operator<
(
detail::half const & x,
detail::half const & y
)
{
return float(x) < float(y);
}
GLM_FUNC_QUALIFIER bool operator<=
(
detail::half const & x,
detail::half const & y
)
{
return float(x) <= float(y);
}
GLM_FUNC_QUALIFIER bool operator>
(
detail::half const & x,
detail::half const & y
)
{
return float(x) > float(y);
}
GLM_FUNC_QUALIFIER bool operator>=
(
detail::half const & x,
detail::half const & y
)
{
return float(x) >= float(y);
}
}//namespace detail
}//namespace glm

142
Glm/core/type_int.hpp

@ -0,0 +1,142 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_int.hpp
/// @date 2008-08-22 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_int
#define glm_core_type_int
#include "setup.hpp"
#include "_detail.hpp"
namespace glm{
namespace detail
{
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);
GLM_DETAIL_IS_INT(signed int);
GLM_DETAIL_IS_INT(signed long);
GLM_DETAIL_IS_UINT(unsigned char);
GLM_DETAIL_IS_UINT(unsigned short);
GLM_DETAIL_IS_UINT(unsigned int);
GLM_DETAIL_IS_UINT(unsigned long);
#if(GLM_LANG >= GLM_LANG_CXX0X)
GLM_DETAIL_IS_INT(signed long long);
GLM_DETAIL_IS_UINT(unsigned long long);
#else
GLM_DETAIL_IS_INT(highp_int_t);
GLM_DETAIL_IS_UINT(highp_uint_t);
#endif
}//namespace detail
/// @addtogroup core_precision
/// @{
/// Low precision signed integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_int_t lowp_int;
/// Medium precision signed integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_int_t mediump_int;
/// High precision signed integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::highp_int_t highp_int;
/// Low precision unsigned integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_uint_t lowp_uint;
/// Medium precision unsigned integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_uint_t mediump_uint;
/// High precision unsigned integer.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::highp_uint_t highp_uint;
#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef mediump_int int_t;
#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef highp_int int_t;
#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
typedef mediump_int int_t;
#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
typedef lowp_int int_t;
#else
# error "GLM error: multiple default precision requested for signed interger types"
#endif
#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef mediump_uint uint_t;
#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef highp_uint uint_t;
#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
typedef mediump_uint uint_t;
#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_uint uint_t;
#else
# error "GLM error: multiple default precision requested for unsigned interger types"
#endif
/// Unsigned integer type.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
typedef uint_t uint;
/// @}
}//namespace glm
#endif//glm_core_type_int

41
Glm/core/type_mat.hpp

@ -0,0 +1,41 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat.hpp
/// @date 2010-01-26 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat
#define glm_core_type_mat
#include "type_gentype.hpp"
namespace glm{
namespace detail
{
}//namespace detail
}//namespace glm
#endif//glm_core_type_mat

27
Glm/core/type_mat.inl

@ -0,0 +1,27 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat.inl
/// @date 2011-06-15 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////

314
Glm/core/type_mat2x2.hpp

@ -0,0 +1,314 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x2.hpp
/// @date 2005-01-27 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat2x2
#define glm_core_type_mat2x2
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat2x2
{
// Implementation detail
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec2<T> row_type;
typedef tmat2x2<T> type;
typedef tmat2x2<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
public:
// Implementation detail
GLM_FUNC_DECL tmat2x2<T> _inverse() const;
private:
//////////////////////////////////////
// Implementation detail
col_type value[2];
public:
//////////////////////////////////////
// Constructors
GLM_FUNC_DECL tmat2x2();
GLM_FUNC_DECL tmat2x2(
tmat2x2 const & m);
GLM_FUNC_DECL explicit tmat2x2(
ctor Null);
GLM_FUNC_DECL explicit tmat2x2(
value_type const & x);
GLM_FUNC_DECL explicit tmat2x2(
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2);
GLM_FUNC_DECL explicit tmat2x2(
col_type const & v1,
col_type const & v2);
//////////////////////////////////////
// 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> const & v1,
tvec2<V> const & v2);
//////////////////////////////////////
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator++();
GLM_FUNC_DECL tmat2x2<T> & operator--();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator+ (
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator+ (
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator+ (
tmat2x2<T> const & m1,
tmat2x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator- (
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator- (
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator- (
tmat2x2<T> const & m1,
tmat2x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator* (
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator* (
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat2x2<T>::col_type operator* (
tmat2x2<T> const & m,
typename tmat2x2<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat2x2<T>::row_type operator* (
typename tmat2x2<T>::col_type const & v,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator* (
tmat2x2<T> const & m1,
tmat2x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator* (
tmat2x2<T> const & m1,
tmat3x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator* (
tmat2x2<T> const & m1,
tmat4x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator/ (
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator/ (
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat2x2<T>::col_type operator/ (
tmat2x2<T> const & m,
typename tmat2x2<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat2x2<T>::row_type operator/ (
typename tmat2x2<T>::col_type const & v,
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator/ (
tmat2x2<T> const & m1,
tmat2x2<T> const & m2);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat2x2<T> const operator- (
tmat2x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> const operator-- (
tmat2x2<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> const operator++ (
tmat2x2<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<lowp_float> lowp_mat2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<mediump_float> mediump_mat2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<highp_float> highp_mat2;
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<lowp_float> lowp_mat2x2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<mediump_float> mediump_mat2x2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x2<highp_float> highp_mat2x2;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat2x2.inl"
#endif
#endif //glm_core_type_mat2x2

688
Glm/core/type_mat2x2.inl

@ -0,0 +1,688 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x2.inl
/// @date 2005-01-16 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x2<T>::size_type tmat2x2<T>::length() const
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
{
return 2;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type &
tmat2x2<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type const &
tmat2x2<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2()
{
this->value[0] = col_type(1, 0);
this->value[1] = col_type(0, 1);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat2x2<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero);
this->value[1] = col_type(Zero, s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1
)
{
this->value[0] = col_type(x0, y0);
this->value[1] = col_type(x1, y1);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
col_type const & v0,
col_type const & v1
)
{
this->value[0] = v0;
this->value[1] = v1;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat2x2<T>::tmat2x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T>(value_type(s), Zero);
this->value[1] = tvec2<T>(Zero, value_type(s));
}
template <typename T>
template <typename X1, typename Y1, typename X2, typename Y2>
GLM_FUNC_DECL tmat2x2<T>::tmat2x2
(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2
)
{
this->value[0] = col_type(value_type(x1), value_type(y1));
this->value[1] = col_type(value_type(x2), value_type(y2));
}
template <typename T>
template <typename V1, typename V2>
GLM_FUNC_DECL tmat2x2<T>::tmat2x2
(
tvec2<V1> const & v1,
tvec2<V2> const & v2
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
}
//////////////////////////////////////////////////////////////
// mat2x2 matrix conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat2x2<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat3x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat4x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> tmat2x2<T>::_inverse() const
{
typename tmat2x2<T>::value_type Determinant = this->value[0][0] * this->value[1][1] - this->value[1][0] * this->value[0][1];
tmat2x2<T> Inverse(
+ this->value[1][1] / Determinant,
- this->value[0][1] / Determinant,
- this->value[1][0] / Determinant,
+ this->value[0][0] / Determinant);
return Inverse;
}
//////////////////////////////////////////////////////////////
// mat2x2 operators
// This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
(
tmat2x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
(
tmat2x2<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
(
tmat2x2<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
(
tmat2x2<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*=
(
tmat2x2<U> const & m
)
{
return (*this = *this * m);
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/=
(
tmat2x2<U> const & m
)
{
return (*this = *this / m);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator++ ()
{
++this->value[0];
++this->value[1];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-- ()
{
--this->value[0];
--this->value[1];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator+
(
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s
)
{
return tmat2x2<T>(
m[0] + s,
m[1] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator+
(
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m
)
{
return tmat2x2<T>(
m[0] + s,
m[1] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator+
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return tmat2x2<T>(
m1[0] + m2[0],
m1[1] + m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator-
(
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s
)
{
return tmat2x2<T>(
m[0] - s,
m[1] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator-
(
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m
)
{
return tmat2x2<T>(
s - m[0],
s - m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator-
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return tmat2x2<T>(
m1[0] - m2[0],
m1[1] - m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator*
(
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s
)
{
return tmat2x2<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator*
(
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m
)
{
return tmat2x2<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator*
(
tmat2x2<T> const & m,
typename tmat2x2<T>::row_type const & v
)
{
return detail::tvec2<T>(
m[0][0] * v.x + m[1][0] * v.y,
m[0][1] * v.x + m[1][1] * v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator*
(
typename tmat2x2<T>::col_type const & v,
tmat2x2<T> const & m
)
{
return detail::tvec2<T>(
v.x * m[0][0] + v.y * m[0][1],
v.x * m[1][0] + v.y * m[1][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator*
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return tmat2x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator*
(
tmat2x2<T> const & m1,
tmat3x2<T> const & m2
)
{
return tmat3x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator*
(
tmat2x2<T> const & m1,
tmat4x2<T> const & m2
)
{
return tmat4x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator/
(
tmat2x2<T> const & m,
typename tmat2x2<T>::value_type const & s
)
{
return tmat2x2<T>(
m[0] / s,
m[1] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator/
(
typename tmat2x2<T>::value_type const & s,
tmat2x2<T> const & m
)
{
return tmat2x2<T>(
s / m[0],
s / m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator/
(
tmat2x2<T> const & m,
typename tmat2x2<T>::row_type & v
)
{
return m._inverse() * v;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator/
(
typename tmat2x2<T>::col_type const & v,
tmat2x2<T> const & m
)
{
return v * m._inverse();
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator/
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return m1 * m2._inverse();
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> const operator-
(
tmat2x2<T> const & m
)
{
return tmat2x2<T>(
-m[0],
-m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> const operator++
(
tmat2x2<T> const & m,
int
)
{
return tmat2x2<T>(
m[0] + T(1),
m[1] + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> const operator--
(
tmat2x2<T> const & m,
int
)
{
return tmat2x2<T>(
m[0] - T(1),
m[1] - T(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat2x2<T> const & m1,
tmat2x2<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

258
Glm/core/type_mat2x3.hpp

@ -0,0 +1,258 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x3.hpp
/// @date 2006-10-01 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat2x3
#define glm_core_type_mat2x3
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat2x3
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec2<T> row_type;
typedef tmat2x3<T> type;
typedef tmat3x2<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[2];
public:
// Constructors
GLM_FUNC_DECL tmat2x3();
GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
GLM_FUNC_DECL explicit tmat2x3(
ctor);
GLM_FUNC_DECL explicit tmat2x3(
value_type const & s);
GLM_FUNC_DECL explicit tmat2x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1);
GLM_FUNC_DECL explicit tmat2x3(
col_type const & v0,
col_type const & v1);
//////////////////////////////////////
// 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,
X2 const & x2, Y2 const & y2, Z2 const & z2);
template <typename U, typename V>
GLM_FUNC_DECL explicit tmat2x3(
tvec3<U> const & v1,
tvec3<V> const & v2);
//////////////////////////////////////
// Matrix conversion
template <typename U>
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x3<T> & operator= (tmat2x3<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator= (tmat2x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x3<T> & operator/= (U s);
GLM_FUNC_DECL tmat2x3<T> & operator++ ();
GLM_FUNC_DECL tmat2x3<T> & operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator+ (
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator+ (
tmat2x3<T> const & m1,
tmat2x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator- (
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator- (
tmat2x3<T> const & m1,
tmat2x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
typename tmat2x3<T>::value_type const & s,
tmat2x3<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat2x3<T>::col_type operator* (
tmat2x3<T> const & m,
typename tmat2x3<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat2x3<T>::row_type operator* (
typename tmat2x3<T>::col_type const & v,
tmat2x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
tmat2x3<T> const & m1,
tmat2x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator* (
tmat2x3<T> const & m1,
tmat3x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator* (
tmat2x3<T> const & m1,
tmat4x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator/ (
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator/ (
typename tmat2x3<T>::value_type const & s,
tmat2x3<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat2x3<T> const operator- (
tmat2x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> const operator-- (
tmat2x3<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> const operator++ (
tmat2x3<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<lowp_float> lowp_mat2x3;
/// 2 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<mediump_float> mediump_mat2x3;
/// 2 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x3<highp_float> highp_mat2x3;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat2x3.inl"
#endif
#endif //glm_core_type_mat2x3

633
Glm/core/type_mat2x3.inl

@ -0,0 +1,633 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x3.inl
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x3<T>::size_type tmat2x3<T>::length() const
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
{
return 2;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type &
tmat2x3<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type const &
tmat2x3<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3()
{
this->value[0] = col_type(T(1), T(0), T(0));
this->value[1] = col_type(T(0), T(1), T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat2x3<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
value_type const & s
)
{
this->value[0] = col_type(s, T(0), T(0));
this->value[1] = col_type(T(0), s, T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1
)
{
this->value[0] = col_type(x0, y0, z0);
this->value[1] = col_type(x1, y1, z1);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
col_type const & v0,
col_type const & v1
)
{
this->value[0] = v0;
this->value[1] = v1;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat2x3<T>::tmat2x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
}
template <typename T>
template <
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2>
GLM_FUNC_DECL tmat2x3<T>::tmat2x3
(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2
)
{
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
}
template <typename T>
template <typename V1, typename V2>
GLM_FUNC_DECL tmat2x3<T>::tmat2x3
(
tvec3<V1> const & v1,
tvec3<V2> const & v2
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
}
//////////////////////////////////////
// Matrix conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat2x3<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
(
tmat4x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator=
(
tmat2x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator=
(
tmat2x3<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator+=
(
tmat2x3<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-=
(
tmat2x3<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator*=
(
tmat2x3<U> const & m
)
{
return (*this = tmat2x3<U>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator++ ()
{
++this->value[0];
++this->value[1];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator-- ()
{
--this->value[0];
--this->value[1];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator+
(
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s
)
{
return tmat2x3<T>(
m[0] + s,
m[1] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator+
(
tmat2x3<T> const & m1,
tmat2x3<T> const & m2
)
{
return tmat2x3<T>(
m1[0] + m2[0],
m1[1] + m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator-
(
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s
)
{
return tmat2x3<T>(
m[0] - s,
m[1] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator-
(
tmat2x3<T> const & m1,
tmat2x3<T> const & m2
)
{
return tmat2x3<T>(
m1[0] - m2[0],
m1[1] - m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator*
(
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s
)
{
return tmat2x3<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator*
(
typename tmat2x3<T>::value_type const & s,
tmat2x3<T> const & m
)
{
return tmat2x3<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type operator*
(
tmat2x3<T> const & m,
typename tmat2x3<T>::row_type const & v)
{
return typename tmat2x3<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y,
m[0][1] * v.x + m[1][1] * v.y,
m[0][2] * v.x + m[1][2] * v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x3<T>::row_type operator*
(
typename tmat2x3<T>::col_type const & v,
tmat2x3<T> const & m)
{
return typename tmat2x3<T>::row_type(
v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator*
(
tmat2x3<T> const & m1,
tmat2x2<T> const & m2
)
{
return tmat2x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator*
(
tmat2x3<T> const & m1,
tmat3x2<T> const & m2
)
{
typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
tmat3x3<T> Result(tmat3x3<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator*
(
tmat2x3<T> const & m1,
tmat4x2<T> const & m2
)
{
return tmat4x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator/
(
tmat2x3<T> const & m,
typename tmat2x3<T>::value_type const & s
)
{
return tmat2x3<T>(
m[0] / s,
m[1] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator/
(
typename tmat2x3<T>::value_type const & s,
tmat2x3<T> const & m
)
{
return tmat2x3<T>(
s / m[0],
s / m[1]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> const operator-
(
tmat2x3<T> const & m
)
{
return tmat2x3<T>(
-m[0],
-m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> const operator++
(
tmat2x3<T> const & m,
int
)
{
return tmat2x3<T>(
m[0] + typename tmat2x3<T>::value_type(1),
m[1] + typename tmat2x3<T>::value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> const operator--
(
tmat2x3<T> const & m,
int
)
{
return tmat2x3<T>(
m[0] - typename tmat2x3<T>::value_type(1),
m[1] - typename tmat2x3<T>::value_type(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat2x3<T> const & m1,
tmat2x3<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat2x3<T> const & m1,
tmat2x3<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

260
Glm/core/type_mat2x4.hpp

@ -0,0 +1,260 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x4.hpp
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat2x4
#define glm_core_type_mat2x4
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat2x4
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec2<T> row_type;
typedef tmat2x4<T> type;
typedef tmat4x2<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[2];
public:
// Constructors
GLM_FUNC_DECL tmat2x4();
GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
GLM_FUNC_DECL explicit tmat2x4(
ctor);
GLM_FUNC_DECL explicit tmat2x4(
value_type const & s);
GLM_FUNC_DECL explicit tmat2x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
GLM_FUNC_DECL explicit tmat2x4(
col_type const & v0,
col_type const & v1);
//////////////////////////////////////
// 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>
GLM_FUNC_DECL explicit tmat2x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
template <typename U, typename V>
GLM_FUNC_DECL explicit tmat2x4(
tvec4<U> const & v1,
tvec4<V> const & v2);
//////////////////////////////////////
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat2x4<T>& operator= (tmat2x4<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator= (tmat2x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat2x4<T>& operator/= (U s);
GLM_FUNC_DECL tmat2x4<T>& operator++ ();
GLM_FUNC_DECL tmat2x4<T>& operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator+ (
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator+ (
tmat2x4<T> const & m1,
tmat2x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator- (
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator- (
tmat2x4<T> const & m1,
tmat2x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator* (
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator* (
typename tmat2x4<T>::value_type const & s,
tmat2x4<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat2x4<T>::col_type operator* (
tmat2x4<T> const & m,
typename tmat2x4<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat2x4<T>::row_type operator* (
typename tmat2x4<T>::col_type const & v,
tmat2x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator* (
tmat2x4<T> const & m1,
tmat4x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator* (
tmat2x4<T> const & m1,
tmat2x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator* (
tmat2x4<T> const & m1,
tmat3x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator/ (
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator/ (
typename tmat2x4<T>::value_type const & s,
tmat2x4<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat2x4<T> const operator- (
tmat2x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> const operator-- (
tmat2x4<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> const operator++ (
tmat2x4<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<lowp_float> lowp_mat2x4;
/// 2 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<mediump_float> mediump_mat2x4;
/// 2 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat2x4<highp_float> highp_mat2x4;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat2x4.inl"
#endif
#endif //glm_core_type_mat2x4

652
Glm/core/type_mat2x4.inl

@ -0,0 +1,652 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat2x4.inl
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x4<T>::size_type tmat2x4<T>::length() const
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
{
return 2;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type &
tmat2x4<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type const &
tmat2x4<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4()
{
value_type const Zero(0);
value_type const One(1);
this->value[0] = col_type(One, Zero, Zero, Zero);
this->value[1] = col_type(Zero, One, Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat2x4<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero, Zero, Zero);
this->value[1] = col_type(Zero, s, Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1
)
{
this->value[0] = col_type(x0, y0, z0, w0);
this->value[1] = col_type(x1, y1, z1, w1);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
col_type const & v0,
col_type const & v1
)
{
this->value[0] = v0;
this->value[1] = v1;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat2x4<T>::tmat2x4
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
}
template <typename T>
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2>
GLM_FUNC_DECL tmat2x4<T>::tmat2x4
(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2
)
{
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
}
template <typename T>
template <typename V1, typename V2>
GLM_FUNC_DECL tmat2x4<T>::tmat2x4
(
tvec4<V1> const & v1,
tvec4<V2> const & v2
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
}
//////////////////////////////////////
// Matrix conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat2x4<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat3x4<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator=
(
tmat2x4<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator=
(
tmat2x4<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+=
(
tmat2x4<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-=
(
tmat2x4<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*=
(
tmat2x4<U> const & m
)
{
return (*this = tmat2x4<T>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator++ ()
{
++this->value[0];
++this->value[1];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-- ()
{
--this->value[0];
--this->value[1];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator+
(
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s
)
{
return tmat2x4<T>(
m[0] + s,
m[1] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator+
(
tmat2x4<T> const & m1,
tmat2x4<T> const & m2
)
{
return tmat2x4<T>(
m1[0] + m2[0],
m1[1] + m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator-
(
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s
)
{
return tmat2x4<T>(
m[0] - s,
m[1] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator-
(
tmat2x4<T> const & m1,
tmat2x4<T> const & m2
)
{
return tmat2x4<T>(
m1[0] - m2[0],
m1[1] - m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator*
(
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s
)
{
return tmat2x4<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator*
(
typename tmat2x4<T>::value_type const & s,
tmat2x4<T> const & m
)
{
return tmat2x4<T>(
m[0] * s,
m[1] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type operator*
(
tmat2x4<T> const & m,
typename tmat2x4<T>::row_type const & v
)
{
return typename tmat2x4<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y,
m[0][1] * v.x + m[1][1] * v.y,
m[0][2] * v.x + m[1][2] * v.y,
m[0][3] * v.x + m[1][3] * v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat2x4<T>::row_type operator*
(
typename tmat2x4<T>::col_type const & v,
tmat2x4<T> const & m
)
{
return typename tmat2x4<T>::row_type(
v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator*
(
tmat2x4<T> const & m1,
tmat4x2<T> const & m2
)
{
typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
tmat4x4<T> Result(tmat4x4<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator*
(
tmat2x4<T> const & m1,
tmat2x2<T> const & m2
)
{
return tmat2x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator*
(
tmat2x4<T> const & m1,
tmat3x2<T> const & m2
)
{
return tmat3x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator/
(
tmat2x4<T> const & m,
typename tmat2x4<T>::value_type const & s
)
{
return tmat2x4<T>(
m[0] / s,
m[1] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator/
(
typename tmat2x4<T>::value_type const & s,
tmat2x4<T> const & m
)
{
return tmat2x4<T>(
s / m[0],
s / m[1]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> const operator-
(
tmat2x4<T> const & m
)
{
return tmat2x4<T>(
-m[0],
-m[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> const operator++
(
tmat2x4<T> const & m,
int
)
{
return tmat2x4<T>(
m[0] + typename tmat2x4<T>::value_type(1),
m[1] + typename tmat2x4<T>::value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> const operator--
(
tmat2x4<T> const & m,
int
)
{
return tmat2x4<T>(
m[0] - typename tmat2x4<T>::value_type(1),
m[1] - typename tmat2x4<T>::value_type(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat2x4<T> const & m1,
tmat2x4<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat2x4<T> const & m1,
tmat2x4<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);
}
} //namespace detail
} //namespace glm

265
Glm/core/type_mat3x2.hpp

@ -0,0 +1,265 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x2.hpp
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat3x2
#define glm_core_type_mat3x2
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat3x2
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec3<T> row_type;
typedef tmat3x2<T> type;
typedef tmat2x3<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[3];
public:
// Constructors
GLM_FUNC_DECL tmat3x2();
GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
GLM_FUNC_DECL explicit tmat3x2(
ctor);
GLM_FUNC_DECL explicit tmat3x2(
value_type const & s);
GLM_FUNC_DECL explicit tmat3x2(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2);
GLM_FUNC_DECL explicit tmat3x2(
col_type const & v0,
col_type const & v1,
col_type const & v2);
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x2(
U const & x);
template
<
typename X1, typename Y1,
typename X2, typename Y2,
typename X3, typename Y3
>
GLM_FUNC_DECL explicit tmat3x2(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL explicit tmat3x2(
tvec2<V1> const & v1,
tvec2<V2> const & v2,
tvec2<V3> const & v3);
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x2<T> & operator= (tmat3x2<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator= (tmat3x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x2<T> & operator/= (U s);
GLM_FUNC_DECL tmat3x2<T> & operator++ ();
GLM_FUNC_DECL tmat3x2<T> & operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator+ (
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator+ (
tmat3x2<T> const & m1,
tmat3x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator- (
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator- (
tmat3x2<T> const & m1,
tmat3x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator* (
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator* (
typename tmat3x2<T>::value_type const & s,
tmat3x2<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat3x2<T>::col_type operator* (
tmat3x2<T> const & m,
typename tmat3x2<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat3x2<T>::row_type operator* (
typename tmat3x2<T>::col_type const & v,
tmat3x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x2<T> operator* (
tmat3x2<T> const & m1,
tmat2x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator* (
tmat3x2<T> const & m1,
tmat3x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator* (
tmat3x2<T> const & m1,
tmat4x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator/ (
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator/ (
typename tmat3x2<T>::value_type const & s,
tmat3x2<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat3x2<T> const operator- (
tmat3x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> const operator-- (
tmat3x2<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> const operator++ (
tmat3x2<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<lowp_float> lowp_mat3x2;
/// 3 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<mediump_float> mediump_mat3x2;
/// 3 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x2<highp_float> highp_mat3x2;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat3x2.inl"
#endif
#endif //glm_core_type_mat3x2

670
Glm/core/type_mat3x2.inl

@ -0,0 +1,670 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x2.inl
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x2<T>::size_type tmat3x2<T>::length() const
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
{
return 3;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type &
tmat3x2<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type const &
tmat3x2<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2()
{
this->value[0] = col_type(1, 0);
this->value[1] = col_type(0, 1);
this->value[2] = col_type(0, 0);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat3x2<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
value_type const & s
)
{
this->value[0] = col_type(s, 0);
this->value[1] = col_type(0, s);
this->value[2] = col_type(0, 0);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2
)
{
this->value[0] = col_type(x0, y0);
this->value[1] = col_type(x1, y1);
this->value[2] = col_type(x2, y2);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
col_type const & v0,
col_type const & v1,
col_type const & v2
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat3x2<T>::tmat3x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T>(value_type(s), Zero);
this->value[1] = tvec2<T>(Zero, value_type(s));
this->value[2] = tvec2<T>(Zero);
}
template <typename T>
template <
typename X1, typename Y1,
typename X2, typename Y2,
typename X3, typename Y3>
GLM_FUNC_DECL tmat3x2<T>::tmat3x2
(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3
)
{
this->value[0] = col_type(value_type(x1), value_type(y1));
this->value[1] = col_type(value_type(x2), value_type(y2));
this->value[2] = col_type(value_type(x3), value_type(y3));
}
template <typename T>
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x2<T>::tmat3x2
(
tvec2<V1> const & v1,
tvec2<V2> const & v2,
tvec2<V3> const & v3
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
}
//////////////////////////////////////////////////////////////
// mat3x2 matrix conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat3x2<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat2x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = col_type(T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat4x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator=
(
tmat3x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator=
(
tmat3x2<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+=
(
tmat3x2<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-=
(
tmat3x2<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*=
(
tmat3x2<U> const & m
)
{
return (*this = tmat3x2<T>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator+
(
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s
)
{
return tmat3x2<T>(
m[0] + s,
m[1] + s,
m[2] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator+
(
tmat3x2<T> const & m1,
tmat3x2<T> const & m2
)
{
return tmat3x2<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator-
(
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s
)
{
return tmat3x2<T>(
m[0] - s,
m[1] - s,
m[2] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator-
(
tmat3x2<T> const & m1,
tmat3x2<T> const & m2
)
{
return tmat3x2<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator*
(
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s
)
{
return tmat3x2<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator*
(
typename tmat3x2<T>::value_type const & s,
tmat3x2<T> const & m
)
{
return tmat3x2<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type operator*
(
tmat3x2<T> const & m,
typename tmat3x2<T>::row_type const & v)
{
return typename tmat3x2<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x2<T>::row_type operator*
(
typename tmat3x2<T>::col_type const & v,
tmat3x2<T> const & m)
{
return typename tmat3x2<T>::row_type(
v.x * m[0][0] + v.y * m[0][1],
v.x * m[1][0] + v.y * m[1][1],
v.x * m[2][0] + v.y * m[2][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator*
(
tmat3x2<T> const & m1,
tmat2x3<T> const & m2
)
{
const T SrcA00 = m1[0][0];
const T SrcA01 = m1[0][1];
const T SrcA10 = m1[1][0];
const T SrcA11 = m1[1][1];
const T SrcA20 = m1[2][0];
const T SrcA21 = m1[2][1];
const T SrcB00 = m2[0][0];
const T SrcB01 = m2[0][1];
const T SrcB02 = m2[0][2];
const T SrcB10 = m2[1][0];
const T SrcB11 = m2[1][1];
const T SrcB12 = m2[1][2];
tmat2x2<T> Result(tmat2x2<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator*
(
tmat3x2<T> const & m1,
tmat3x3<T> const & m2
)
{
return tmat3x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator*
(
tmat3x2<T> const & m1,
tmat4x3<T> const & m2
)
{
return tmat4x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator/
(
tmat3x2<T> const & m,
typename tmat3x2<T>::value_type const & s
)
{
return tmat3x2<T>(
m[0] / s,
m[1] / s,
m[2] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator/
(
typename tmat3x2<T>::value_type const & s,
tmat3x2<T> const & m
)
{
return tmat3x2<T>(
s / m[0],
s / m[1],
s / m[2]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> const operator-
(
tmat3x2<T> const & m
)
{
return tmat3x2<T>(
-m[0],
-m[1],
-m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> const operator++
(
tmat3x2<T> const & m,
int
)
{
typename tmat3x2<T>::value_type One(1);
return tmat3x2<T>(
m[0] + One,
m[1] + One,
m[2] + One);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> const operator--
(
tmat3x2<T> const & m,
int
)
{
typename tmat3x2<T>::value_type One(1);
return tmat3x2<T>(
m[0] - One,
m[1] - One,
m[2] - One);
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat3x2<T> const & m1,
tmat3x2<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat3x2<T> const & m1,
tmat3x2<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

318
Glm/core/type_mat3x3.hpp

@ -0,0 +1,318 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x3.hpp
/// @date 2005-01-27 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat3x3
#define glm_core_type_mat3x3
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat3x3
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec3<T> row_type;
typedef tmat3x3<T> type;
typedef tmat3x3<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
public:
/// Implementation detail
/// @cond DETAIL
GLM_FUNC_DECL tmat3x3<T> _inverse() const;
/// @endcond
private:
// Data
col_type value[3];
public:
// Constructors
GLM_FUNC_DECL tmat3x3();
GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
GLM_FUNC_DECL explicit tmat3x3(
ctor Null);
GLM_FUNC_DECL explicit tmat3x3(
value_type const & s);
GLM_FUNC_DECL explicit tmat3x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2);
GLM_FUNC_DECL explicit tmat3x3(
col_type const & v0,
col_type const & v1,
col_type const & v2);
//////////////////////////////////////
// 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,
typename X3, typename Y3, typename Z3
>
GLM_FUNC_DECL explicit tmat3x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL explicit tmat3x3(
tvec3<V1> const & v1,
tvec3<V2> const & v2,
tvec3<V3> const & v3);
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x3<T>& operator= (tmat3x3<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator= (tmat3x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator/= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator++ ();
GLM_FUNC_DECL tmat3x3<T>& operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator+ (
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator+ (
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator+ (
tmat3x3<T> const & m1,
tmat3x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator- (
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator- (
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator- (
tmat3x3<T> const & m1,
tmat3x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator* (
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator* (
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat3x3<T>::col_type operator* (
tmat3x3<T> const & m,
typename tmat3x3<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat3x3<T>::row_type operator* (
typename tmat3x3<T>::col_type const & v,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator* (
tmat3x3<T> const & m1,
tmat3x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
tmat3x3<T> const & m1,
tmat2x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator* (
tmat3x3<T> const & m1,
tmat4x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator/ (
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator/ (
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat3x3<T>::col_type operator/ (
tmat3x3<T> const & m,
typename tmat3x3<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat3x3<T>::row_type operator/ (
typename tmat3x3<T>::col_type const & v,
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator/ (
tmat3x3<T> const & m1,
tmat3x3<T> const & m2);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat3x3<T> const operator- (
tmat3x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> const operator-- (
tmat3x3<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> const operator++ (
tmat3x3<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<lowp_float> lowp_mat3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<mediump_float> mediump_mat3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<highp_float> highp_mat3;
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<lowp_float> lowp_mat3x3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<mediump_float> mediump_mat3x3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x3<highp_float> highp_mat3x3;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat3x3.inl"
#endif
#endif //glm_core_type_mat3x3

800
Glm/core/type_mat3x3.inl

@ -0,0 +1,800 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x3.inl
/// @date 2005-01-27 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x3<T>::size_type tmat3x3<T>::length() const
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
{
return 3;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type &
tmat3x3<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type const &
tmat3x3<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
{
value_type const Zero(0);
value_type const One(1);
this->value[0] = col_type(One, Zero, Zero);
this->value[1] = col_type(Zero, One, Zero);
this->value[2] = col_type(Zero, Zero, One);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat3x3<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero, Zero);
this->value[1] = col_type(Zero, s, Zero);
this->value[2] = col_type(Zero, Zero, s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2
)
{
this->value[0] = col_type(x0, y0, z0);
this->value[1] = col_type(x1, y1, z1);
this->value[2] = col_type(x2, y2, z2);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
col_type const & v0,
col_type const & v1,
col_type const & v2
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat3x3<T>::tmat3x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
}
template <typename T>
template <
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3>
GLM_FUNC_DECL tmat3x3<T>::tmat3x3
(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3
)
{
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
}
template <typename T>
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x3<T>::tmat3x3
(
tvec3<V1> const & v1,
tvec3<V2> const & v2,
tvec3<V3> const & v3
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
}
//////////////////////////////////////////////////////////////
// Conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat3x3<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat2x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
(
tmat4x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
}
//////////////////////////////////////////////////////////////
// Operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
(
tmat3x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
(
tmat3x3<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
(
tmat3x3<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-=
(
tmat3x3<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*=
(
tmat3x3<U> const & m
)
{
return (*this = *this * m);
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/=
(
tmat3x3<U> const & m
)
{
return (*this = *this / m);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
{
T S00 = value[0][0];
T S01 = value[0][1];
T S02 = value[0][2];
T S10 = value[1][0];
T S11 = value[1][1];
T S12 = value[1][2];
T S20 = value[2][0];
T S21 = value[2][1];
T S22 = value[2][2];
/*
tmat3x3<T> Inverse(
+ (S11 * S22 - S21 * S12),
- (S10 * S22 - S20 * S12),
+ (S10 * S21 - S20 * S11),
- (S01 * S22 - S21 * S02),
+ (S00 * S22 - S20 * S02),
- (S00 * S21 - S20 * S01),
+ (S01 * S12 - S11 * S02),
- (S00 * S12 - S10 * S02),
+ (S00 * S11 - S10 * S01));
*/
tmat3x3<T> Inverse(
S11 * S22 - S21 * S12,
S12 * S20 - S22 * S10,
S10 * S21 - S20 * S11,
S02 * S21 - S01 * S22,
S00 * S22 - S02 * S20,
S01 * S20 - S00 * S21,
S12 * S01 - S11 * S02,
S10 * S02 - S12 * S00,
S11 * S00 - S10 * S01);
T Determinant = S00 * (S11 * S22 - S21 * S12)
- S10 * (S01 * S22 - S21 * S02)
+ S20 * (S01 * S12 - S11 * S02);
Inverse /= Determinant;
return Inverse;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator+
(
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s
)
{
return tmat3x3<T>(
m[0] + s,
m[1] + s,
m[2] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator+
(
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m
)
{
return tmat3x3<T>(
m[0] + s,
m[1] + s,
m[2] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator+
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
return tmat3x3<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator-
(
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s
)
{
return tmat3x3<T>(
m[0] - s,
m[1] - s,
m[2] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator-
(
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m
)
{
return tmat3x3<T>(
s - m[0],
s - m[1],
s - m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator-
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
return tmat3x3<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator*
(
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s
)
{
return tmat3x3<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator*
(
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m
)
{
return tmat3x3<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator*
(
tmat3x3<T> const & m,
typename tmat3x3<T>::row_type const & v
)
{
return typename tmat3x3<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator*
(
typename tmat3x3<T>::col_type const & v,
tmat3x3<T> const & m
)
{
return typename tmat3x3<T>::row_type(
m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator*
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
tmat3x3<T> Result(tmat3x3<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator*
(
tmat3x3<T> const & m1,
tmat2x3<T> const & m2
)
{
return tmat2x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator*
(
tmat3x3<T> const & m1,
tmat4x3<T> const & m2
)
{
return tmat4x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator/
(
tmat3x3<T> const & m,
typename tmat3x3<T>::value_type const & s
)
{
return tmat3x3<T>(
m[0] / s,
m[1] / s,
m[2] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator/
(
typename tmat3x3<T>::value_type const & s,
tmat3x3<T> const & m
)
{
return tmat3x3<T>(
s / m[0],
s / m[1],
s / m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator/
(
tmat3x3<T> const & m,
typename tmat3x3<T>::row_type const & v
)
{
return m._inverse() * v;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator/
(
typename tmat3x3<T>::col_type const & v,
tmat3x3<T> const & m
)
{
return v * m._inverse();
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator/
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
return m1 * m2._inverse();
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> const operator-
(
tmat3x3<T> const & m
)
{
return tmat3x3<T>(
-m[0],
-m[1],
-m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> const operator++
(
tmat3x3<T> const & m,
int
)
{
return tmat3x3<T>(
m[0] + T(1),
m[1] + T(1),
m[2] + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> const operator--
(
tmat3x3<T> const & m,
int
)
{
return tmat3x3<T>(
m[0] - T(1),
m[1] - T(1),
m[2] - T(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat3x3<T> const & m1,
tmat3x3<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

266
Glm/core/type_mat3x4.hpp

@ -0,0 +1,266 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x4.hpp
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat3x4
#define glm_core_type_mat3x4
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat3x4
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec3<T> row_type;
typedef tmat3x4<T> type;
typedef tmat4x3<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[3];
public:
// Constructors
GLM_FUNC_DECL tmat3x4();
GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
GLM_FUNC_DECL explicit tmat3x4(
ctor Null);
GLM_FUNC_DECL explicit tmat3x4(
value_type const & s);
GLM_FUNC_DECL explicit tmat3x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
GLM_FUNC_DECL explicit tmat3x4(
col_type const & v0,
col_type const & v1,
col_type const & v2);
//////////////////////////////////////
// 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,
typename X3, typename Y3, typename Z3, typename W3
>
GLM_FUNC_DECL explicit tmat3x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL explicit tmat3x4(
tvec4<V1> const & v1,
tvec4<V2> const & v2,
tvec4<V3> const & v3);
// Matrix conversion
template <typename U>
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat3x4<T> & operator= (tmat3x4<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator= (tmat3x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat3x4<T> & operator/= (U s);
GLM_FUNC_DECL tmat3x4<T> & operator++ ();
GLM_FUNC_DECL tmat3x4<T> & operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator+ (
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator+ (
tmat3x4<T> const & m1,
tmat3x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator- (
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator- (
tmat3x4<T> const & m1,
tmat3x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator* (
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator* (
typename tmat3x4<T>::value_type const & s,
tmat3x4<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat3x4<T>::col_type operator* (
tmat3x4<T> const & m,
typename tmat3x4<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat3x4<T>::row_type operator* (
typename tmat3x4<T>::col_type const & v,
tmat3x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator* (
tmat3x4<T> const & m1,
tmat4x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator* (
tmat3x4<T> const & m1,
tmat2x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator* (
tmat3x4<T> const & m1,
tmat3x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator/ (
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator/ (
typename tmat3x4<T>::value_type const & s,
tmat3x4<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat3x4<T> const operator- (
tmat3x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> const operator-- (
tmat3x4<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> const operator++ (
tmat3x4<T> const & m,
int);
}//namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<lowp_float> lowp_mat3x4;
/// 3 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<mediump_float> mediump_mat3x4;
/// 3 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat3x4<highp_float> highp_mat3x4;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat3x4.inl"
#endif
#endif //glm_core_type_mat3x4

700
Glm/core/type_mat3x4.inl

@ -0,0 +1,700 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat3x4.inl
/// @date 2006-08-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat3x4<T>::size_type tmat3x4<T>::length() const
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
{
return 3;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type &
tmat3x4<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type const &
tmat3x4<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4()
{
this->value[0] = col_type(1, 0, 0, 0);
this->value[1] = col_type(0, 1, 0, 0);
this->value[2] = col_type(0, 0, 1, 0);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat3x4<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero, Zero, Zero);
this->value[1] = col_type(Zero, s, Zero, Zero);
this->value[2] = col_type(Zero, Zero, s, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2
)
{
this->value[0] = col_type(x0, y0, z0, w0);
this->value[1] = col_type(x1, y1, z1, w1);
this->value[2] = col_type(x2, y2, z2, w2);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
col_type const & v0,
col_type const & v1,
col_type const & v2
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat3x4<T>::tmat3x4
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
}
template <typename T>
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,
typename X3, typename Y3, typename Z3, typename W3>
GLM_FUNC_DECL tmat3x4<T>::tmat3x4
(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3
)
{
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
}
template <typename T>
template <typename V1, typename V2, typename V3>
GLM_FUNC_DECL tmat3x4<T>::tmat3x4
(
tvec4<V1> const & v1,
tvec4<V2> const & v2,
tvec4<V3> const & v3
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
}
// Conversion
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat3x4<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
this->value[2] = col_type(T(0), T(0), T(1), T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
this->value[2] = col_type(m[2], T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
this->value[2] = col_type(T(0), T(0), T(1), T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
this->value[2] = col_type(m[2], T(0), T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(T(0), T(0), T(1), T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
this->value[2] = col_type(m[2], detail::tvec2<T>(T(1), T(0)));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
this->value[2] = col_type(m[2], T(0));
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator=
(
tmat3x4<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator=
(
tmat3x4<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+=
(
tmat3x4<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-=
(
tmat3x4<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*=
(
tmat3x4<U> const & m
)
{
return (*this = tmat3x4<T>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator+
(
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s
)
{
return tmat3x4<T>(
m[0] + s,
m[1] + s,
m[2] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator+
(
tmat3x4<T> const & m1,
tmat3x4<T> const & m2
)
{
return tmat3x4<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator-
(
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s
)
{
return tmat3x4<T>(
m[0] - s,
m[1] - s,
m[2] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator-
(
tmat3x4<T> const & m1,
tmat3x4<T> const & m2
)
{
return tmat3x4<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator*
(
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s
)
{
return tmat3x4<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator*
(
typename tmat3x4<T>::value_type const & s,
tmat3x4<T> const & m
)
{
return tmat3x4<T>(
m[0] * s,
m[1] * s,
m[2] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type operator*
(
tmat3x4<T> const & m,
typename tmat3x4<T>::row_type const & v
)
{
return typename tmat3x4<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat3x4<T>::row_type operator*
(
typename tmat3x4<T>::col_type const & v,
tmat3x4<T> const & m
)
{
return typename tmat3x4<T>::row_type(
v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator*
(
tmat3x4<T> const & m1,
tmat4x3<T> const & m2
)
{
const T SrcA00 = m1[0][0];
const T SrcA01 = m1[0][1];
const T SrcA02 = m1[0][2];
const T SrcA03 = m1[0][3];
const T SrcA10 = m1[1][0];
const T SrcA11 = m1[1][1];
const T SrcA12 = m1[1][2];
const T SrcA13 = m1[1][3];
const T SrcA20 = m1[2][0];
const T SrcA21 = m1[2][1];
const T SrcA22 = m1[2][2];
const T SrcA23 = m1[2][3];
const T SrcB00 = m2[0][0];
const T SrcB01 = m2[0][1];
const T SrcB02 = m2[0][2];
const T SrcB10 = m2[1][0];
const T SrcB11 = m2[1][1];
const T SrcB12 = m2[1][2];
const T SrcB20 = m2[2][0];
const T SrcB21 = m2[2][1];
const T SrcB22 = m2[2][2];
const T SrcB30 = m2[3][0];
const T SrcB31 = m2[3][1];
const T SrcB32 = m2[3][2];
tmat4x4<T> Result(tmat4x4<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator*
(
tmat3x4<T> const & m1,
tmat2x3<T> const & m2
)
{
return tmat2x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator*
(
tmat3x4<T> const & m1,
tmat3x3<T> const & m2
)
{
return tmat3x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator/
(
tmat3x4<T> const & m,
typename tmat3x4<T>::value_type const & s
)
{
return tmat3x4<T>(
m[0] / s,
m[1] / s,
m[2] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator/
(
typename tmat3x4<T>::value_type const & s,
tmat3x4<T> const & m
)
{
return tmat3x4<T>(
s / m[0],
s / m[1],
s / m[2]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> const operator-
(
tmat3x4<T> const & m
)
{
return tmat3x4<T>(
-m[0],
-m[1],
-m[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> const operator++
(
tmat3x4<T> const & m,
int
)
{
return tmat3x4<T>(
m[0] + T(1),
m[1] + T(1),
m[2] + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> const operator--
(
tmat3x4<T> const & m,
int
)
{
return tmat3x4<T>(
m[0] - T(1),
m[1] - T(1),
m[2] - T(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat3x4<T> const & m1,
tmat3x4<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat3x4<T> const & m1,
tmat3x4<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
}
} //namespace detail
} //namespace glm

270
Glm/core/type_mat4x2.hpp

@ -0,0 +1,270 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x2.hpp
/// @date 2006-10-01 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat4x2
#define glm_core_type_mat4x2
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat4x2
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec4<T> row_type;
typedef tmat4x2<T> type;
typedef tmat2x4<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[4];
public:
// Constructors
GLM_FUNC_DECL tmat4x2();
GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
GLM_FUNC_DECL explicit tmat4x2(
ctor Null);
GLM_FUNC_DECL explicit tmat4x2(
value_type const & x);
GLM_FUNC_DECL explicit tmat4x2(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2,
value_type const & x3, value_type const & y3);
GLM_FUNC_DECL explicit tmat4x2(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3);
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x2(
U const & x);
template
<
typename X1, typename Y1,
typename X2, typename Y2,
typename X3, typename Y3,
typename X4, typename Y4
>
GLM_FUNC_DECL explicit tmat4x2(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3,
X4 const & x4, Y4 const & y4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL explicit tmat4x2(
tvec2<V1> const & v1,
tvec2<V2> const & v2,
tvec2<V3> const & v3,
tvec2<V4> const & v4);
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x2<T>& operator= (tmat4x2<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator= (tmat4x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x2<T>& operator/= (U s);
GLM_FUNC_DECL tmat4x2<T>& operator++ ();
GLM_FUNC_DECL tmat4x2<T>& operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator+ (
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator+ (
tmat4x2<T> const & m1,
tmat4x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator- (
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator- (
tmat4x2<T> const & m1,
tmat4x2<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator* (
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator* (
typename tmat4x2<T>::value_type const & s,
tmat4x2<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat4x2<T>::col_type operator* (
tmat4x2<T> const & m,
typename tmat4x2<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat4x2<T>::row_type operator* (
typename tmat4x2<T>::col_type const & v,
tmat4x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat3x2<T> operator* (
tmat4x2<T> const & m1,
tmat3x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator* (
tmat4x2<T> const & m1,
tmat4x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
tmat4x3<T> const & m1,
tmat2x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator/ (
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> operator/ (
typename tmat4x2<T>::value_type const & s,
tmat4x2<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat4x2<T> const operator- (
tmat4x2<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> const operator-- (
tmat4x2<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat4x2<T> const operator++ (
tmat4x2<T> const & m,
int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<lowp_float> lowp_mat4x2;
/// 4 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<mediump_float> mediump_mat4x2;
/// 4 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x2<highp_float> highp_mat4x2;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat4x2.inl"
#endif
#endif //glm_core_type_mat4x2

716
Glm/core/type_mat4x2.inl

@ -0,0 +1,716 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x2.inl
/// @date 2006-10-01 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x2<T>::size_type tmat4x2<T>::length() const
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
{
return 2;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
{
return 4;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type &
tmat4x2<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type const &
tmat4x2<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2()
{
value_type const Zero(0);
value_type const One(1);
this->value[0] = col_type(One, Zero);
this->value[1] = col_type(Zero, One);
this->value[2] = col_type(Zero, Zero);
this->value[3] = col_type(Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat4x2<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
this->value[3] = m.value[3];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero);
this->value[1] = col_type(Zero, s);
this->value[2] = col_type(Zero, Zero);
this->value[3] = col_type(Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2,
value_type const & x3, value_type const & y3
)
{
this->value[0] = col_type(x0, y0);
this->value[1] = col_type(x1, y1);
this->value[2] = col_type(x2, y2);
this->value[3] = col_type(x3, y3);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
this->value[3] = v3;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat4x2<T>::tmat4x2
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec2<T>(value_type(s), Zero);
this->value[1] = tvec2<T>(Zero, value_type(s));
this->value[2] = tvec2<T>(Zero, Zero);
this->value[3] = tvec2<T>(Zero, Zero);
}
template <typename T>
template <
typename X1, typename Y1,
typename X2, typename Y2,
typename X3, typename Y3,
typename X4, typename Y4>
GLM_FUNC_DECL tmat4x2<T>::tmat4x2
(
X1 const & x1, Y1 const & y1,
X2 const & x2, Y2 const & y2,
X3 const & x3, Y3 const & y3,
X4 const & x4, Y4 const & y4
)
{
this->value[0] = col_type(value_type(x1), value_type(y1));
this->value[1] = col_type(value_type(x2), value_type(y2));
this->value[2] = col_type(value_type(x3), value_type(y3));
this->value[3] = col_type(value_type(x4), value_type(y4));
}
template <typename T>
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x2<T>::tmat4x2
(
tvec2<V1> const & v1,
tvec2<V2> const & v2,
tvec2<V3> const & v3,
tvec2<V4> const & v4
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
this->value[3] = col_type(v4);
}
// Conversion
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat4x2<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator=
(
tmat4x2<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator=
(
tmat4x2<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
this->value[3] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+=
(
tmat4x2<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
this->value[3] += m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
this->value[3] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-=
(
tmat4x2<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
this->value[3] -= m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
this->value[3] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*=
(
tmat4x2<U> const & m
)
{
return (*this = tmat4x2<T>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
this->value[3] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
++this->value[3];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
--this->value[3];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator+
(
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s
)
{
return tmat4x2<T>(
m[0] + s,
m[1] + s,
m[2] + s,
m[3] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator+
(
tmat4x2<T> const & m1,
tmat4x2<T> const & m2
)
{
return tmat4x2<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2],
m1[3] + m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator-
(
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s
)
{
return tmat4x2<T>(
m[0] - s,
m[1] - s,
m[2] - s,
m[3] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator-
(
tmat4x2<T> const & m1,
tmat4x2<T> const & m2
)
{
return tmat4x2<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2],
m1[3] - m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator*
(
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s
)
{
return tmat4x2<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator*
(
typename tmat4x2<T>::value_type const & s,
tmat4x2<T> const & m
)
{
return tmat4x2<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type operator*
(
tmat4x2<T> const & m,
typename tmat4x2<T>::row_type const & v)
{
return typename tmat4x2<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x2<T>::row_type operator*
(
typename tmat4x2<T>::col_type const & v,
tmat4x2<T> const & m)
{
return typename tmat4x2<T>::row_type(
v.x * m[0][0] + v.y * m[0][1],
v.x * m[1][0] + v.y * m[1][1],
v.x * m[2][0] + v.y * m[2][1],
v.x * m[3][0] + v.y * m[3][1]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T> operator*
(
tmat4x2<T> const & m1,
tmat2x4<T> const & m2
)
{
T const SrcA00 = m1[0][0];
T const SrcA01 = m1[0][1];
T const SrcA10 = m1[1][0];
T const SrcA11 = m1[1][1];
T const SrcA20 = m1[2][0];
T const SrcA21 = m1[2][1];
T const SrcA30 = m1[3][0];
T const SrcA31 = m1[3][1];
T const SrcB00 = m2[0][0];
T const SrcB01 = m2[0][1];
T const SrcB02 = m2[0][2];
T const SrcB03 = m2[0][3];
T const SrcB10 = m2[1][0];
T const SrcB11 = m2[1][1];
T const SrcB12 = m2[1][2];
T const SrcB13 = m2[1][3];
tmat2x2<T> Result(tmat2x2<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T> operator*
(
tmat4x2<T> const & m1,
tmat3x4<T> const & m2
)
{
return tmat3x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator*
(
tmat4x2<T> const & m1,
tmat4x4<T> const & m2
)
{
return tmat4x2<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator/
(
tmat4x2<T> const & m,
typename tmat4x2<T>::value_type const & s
)
{
return tmat4x2<T>(
m[0] / s,
m[1] / s,
m[2] / s,
m[3] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> operator/
(
typename tmat4x2<T>::value_type const & s,
tmat4x2<T> const & m
)
{
return tmat4x2<T>(
s / m[0],
s / m[1],
s / m[2],
s / m[3]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> const operator-
(
tmat4x2<T> const & m
)
{
return tmat4x2<T>(
-m[0],
-m[1],
-m[2],
-m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> const operator++
(
tmat4x2<T> const & m,
int
)
{
return tmat4x2<T>(
m[0] + typename tmat4x2<T>::value_type(1),
m[1] + typename tmat4x2<T>::value_type(1),
m[2] + typename tmat4x2<T>::value_type(1),
m[3] + typename tmat4x2<T>::value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T> const operator--
(
tmat4x2<T> const & m,
int
)
{
return tmat4x2<T>(
m[0] - typename tmat4x2<T>::value_type(1),
m[1] - typename tmat4x2<T>::value_type(1),
m[2] - typename tmat4x2<T>::value_type(1),
m[3] - typename tmat4x2<T>::value_type(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat4x2<T> const & m1,
tmat4x2<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat4x2<T> const & m1,
tmat4x2<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm

268
Glm/core/type_mat4x3.hpp

@ -0,0 +1,268 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x3.hpp
/// @date 2006-08-04 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat4x3
#define glm_core_type_mat4x3
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat4x3
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec4<T> row_type;
typedef tmat4x3<T> type;
typedef tmat3x4<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
private:
// Data
col_type value[4];
public:
// Constructors
GLM_FUNC_DECL tmat4x3();
GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
GLM_FUNC_DECL explicit tmat4x3(
ctor Null);
GLM_FUNC_DECL explicit tmat4x3(
value_type const & x);
GLM_FUNC_DECL explicit tmat4x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2,
value_type const & x3, value_type const & y3, value_type const & z3);
GLM_FUNC_DECL explicit tmat4x3(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3);
//////////////////////////////////////
// Conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x3(
U const & x);
template <
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3,
typename X4, typename Y4, typename Z4>
GLM_FUNC_DECL explicit tmat4x3(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3,
X4 const & x4, Y4 const & y4, Z4 const & z4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL explicit tmat4x3(
tvec3<V1> const & v1,
tvec3<V2> const & v2,
tvec3<V3> const & v3,
tvec3<V4> const & v4);
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x3<T> & operator= (tmat4x3<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator= (tmat4x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x3<T> & operator/= (U s);
GLM_FUNC_DECL tmat4x3<T> & operator++ ();
GLM_FUNC_DECL tmat4x3<T> & operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator+ (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator+ (
tmat4x3<T> const & m1,
tmat4x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator- (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator- (
tmat4x3<T> const & m1,
tmat4x3<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator* (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator* (
typename tmat4x3<T>::value_type const & s,
tmat4x3<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat4x3<T>::col_type operator* (
tmat4x3<T> const & m,
typename tmat4x3<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat4x3<T>::row_type operator* (
typename tmat4x3<T>::col_type const & v,
tmat4x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x3<T> operator* (
tmat4x3<T> const & m1,
tmat2x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x3<T> operator* (
tmat4x3<T> const & m1,
tmat3x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator* (
tmat4x3<T> const & m1,
tmat4x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator/ (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> operator/ (
typename tmat4x3<T>::value_type const & s,
tmat4x3<T> const & m);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat4x3<T> const operator- (
tmat4x3<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> const operator-- (
tmat4x3<T> const & m,
int);
template <typename T>
GLM_FUNC_DECL tmat4x3<T> const operator++ (
tmat4x3<T> const & m,
int);
}//namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<lowp_float> lowp_mat4x3;
/// 4 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<mediump_float> mediump_mat4x3;
/// 4 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x3<highp_float> highp_mat4x3;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat4x3.inl"
#endif //GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_mat4x3

725
Glm/core/type_mat4x3.inl

@ -0,0 +1,725 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x3.inl
/// @date 2006-04-17 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x3<T>::size_type tmat4x3<T>::length() const
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::col_size()
{
return 3;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::row_size()
{
return 4;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type &
tmat4x3<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type const &
tmat4x3<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3()
{
value_type const Zero(0);
value_type const One(1);
this->value[0] = col_type(One, Zero, Zero);
this->value[1] = col_type(Zero, One, Zero);
this->value[2] = col_type(Zero, Zero, One);
this->value[3] = col_type(Zero, Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat4x3<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
this->value[3] = m.value[3];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero, Zero);
this->value[1] = col_type(Zero, s, Zero);
this->value[2] = col_type(Zero, Zero, s);
this->value[3] = col_type(Zero, Zero, Zero);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2,
value_type const & x3, value_type const & y3, value_type const & z3
)
{
this->value[0] = col_type(x0, y0, z0);
this->value[1] = col_type(x1, y1, z1);
this->value[2] = col_type(x2, y2, z2);
this->value[3] = col_type(x3, y3, z3);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
this->value[3] = v3;
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat4x3<T>::tmat4x3
(
U const & s
)
{
value_type const Zero(0);
this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
this->value[3] = tvec3<T>(Zero, Zero, Zero);
}
template <typename T>
template <
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
typename X3, typename Y3, typename Z3,
typename X4, typename Y4, typename Z4>
GLM_FUNC_DECL tmat4x3<T>::tmat4x3
(
X1 const & x1, Y1 const & y1, Z1 const & z1,
X2 const & x2, Y2 const & y2, Z2 const & z2,
X3 const & x3, Y3 const & y3, Z3 const & z3,
X4 const & x4, Y4 const & y4, Z4 const & z4
)
{
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4));
}
template <typename T>
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x3<T>::tmat4x3
(
tvec3<V1> const & v1,
tvec3<V2> const & v2,
tvec3<V3> const & v3,
tvec3<V4> const & v4
)
{
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
this->value[3] = col_type(v4);
}
//////////////////////////////////////////////////////////////
// Matrix conversions
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat4x3<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(1));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat4x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(1));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat2x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
this->value[3] = col_type(value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(1));
this->value[3] = col_type(m[3], value_type(0));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
(
tmat3x4<T> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator=
(
tmat4x3<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator=
(
tmat4x3<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
this->value[3] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+=
(
tmat4x3<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
this->value[3] += m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
this->value[3] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-=
(
tmat4x3<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
this->value[3] -= m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
this->value[3] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*=
(
tmat4x3<U> const & m
)
{
return (*this = tmat4x3<T>(*this * m));
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
this->value[3] /= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
++this->value[3];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
--this->value[3];
return *this;
}
//////////////////////////////////////////////////////////////
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s)
{
return tmat4x3<T>(
m[0] + s,
m[1] + s,
m[2] + s,
m[3] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
tmat4x3<T> const & m1,
tmat4x3<T> const & m2)
{
return tmat4x3<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2],
m1[3] + m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s)
{
return tmat4x3<T>(
m[0] - s,
m[1] - s,
m[2] - s,
m[3] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
tmat4x3<T> const & m1,
tmat4x3<T> const & m2)
{
return tmat4x3<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2],
m1[3] - m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s)
{
return tmat4x3<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
typename tmat4x3<T>::value_type const & s,
tmat4x3<T> const & m)
{
return tmat4x3<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type operator*
(
tmat4x3<T> const & m,
typename tmat4x3<T>::row_type const & v)
{
return typename tmat4x3<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x3<T>::row_type operator*
(
typename tmat4x3<T>::col_type const & v,
tmat4x3<T> const & m)
{
return typename tmat4x3<T>::row_type(
v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T> operator*
(
tmat4x3<T> const & m1,
tmat2x4<T> const & m2
)
{
return tmat2x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T> operator*
(
tmat4x3<T> const & m1,
tmat3x4<T> const & m2
)
{
T const SrcA00 = m1[0][0];
T const SrcA01 = m1[0][1];
T const SrcA02 = m1[0][2];
T const SrcA10 = m1[1][0];
T const SrcA11 = m1[1][1];
T const SrcA12 = m1[1][2];
T const SrcA20 = m1[2][0];
T const SrcA21 = m1[2][1];
T const SrcA22 = m1[2][2];
T const SrcA30 = m1[3][0];
T const SrcA31 = m1[3][1];
T const SrcA32 = m1[3][2];
T const SrcB00 = m2[0][0];
T const SrcB01 = m2[0][1];
T const SrcB02 = m2[0][2];
T const SrcB03 = m2[0][3];
T const SrcB10 = m2[1][0];
T const SrcB11 = m2[1][1];
T const SrcB12 = m2[1][2];
T const SrcB13 = m2[1][3];
T const SrcB20 = m2[2][0];
T const SrcB21 = m2[2][1];
T const SrcB22 = m2[2][2];
T const SrcB23 = m2[2][3];
tmat3x3<T> Result(tmat3x3<T>::null);
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator*
(
tmat4x3<T> const & m1,
tmat4x4<T> const & m2
)
{
return tmat4x3<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator/
(
tmat4x3<T> const & m,
typename tmat4x3<T>::value_type const & s
)
{
return tmat4x3<T>(
m[0] / s,
m[1] / s,
m[2] / s,
m[3] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> operator/
(
typename tmat4x3<T>::value_type const & s,
tmat4x3<T> const & m
)
{
return tmat4x3<T>(
s / m[0],
s / m[1],
s / m[2],
s / m[3]);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> const operator-
(
tmat4x3<T> const & m
)
{
return tmat4x3<T>(
-m[0],
-m[1],
-m[2],
-m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> const operator++
(
tmat4x3<T> const & m,
int
)
{
return tmat4x3<T>(
m[0] + T(1),
m[1] + T(1),
m[2] + T(1),
m[3] + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T> const operator--
(
tmat4x3<T> const & m,
int
)
{
return tmat4x3<T>(
m[0] - T(1),
m[1] - T(1),
m[2] - T(1),
m[3] - T(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat4x3<T> const & m1,
tmat4x3<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat4x3<T> const & m1,
tmat4x3<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm

320
Glm/core/type_mat4x4.hpp

@ -0,0 +1,320 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x4.hpp
/// @date 2005-01-27 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_mat4x4
#define glm_core_type_mat4x4
#include "type_mat.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T> struct tmat2x2;
template <typename T> struct tmat2x3;
template <typename T> struct tmat2x4;
template <typename T> struct tmat3x2;
template <typename T> struct tmat3x3;
template <typename T> struct tmat3x4;
template <typename T> struct tmat4x2;
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
template <typename T>
struct tmat4x4
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec4<T> row_type;
typedef tmat4x4<T> type;
typedef tmat4x4<T> transpose_type;
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
public:
/// Implementation detail
/// @cond DETAIL
GLM_FUNC_DECL tmat4x4<T> _inverse() const;
/// @endcond
private:
// Data
col_type value[4];
public:
// Constructors
GLM_FUNC_DECL tmat4x4();
GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
GLM_FUNC_DECL explicit tmat4x4(
ctor Null);
GLM_FUNC_DECL explicit tmat4x4(
value_type const & x);
GLM_FUNC_DECL explicit tmat4x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
GLM_FUNC_DECL explicit tmat4x4(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3);
//////////////////////////////////////
// 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,
typename X3, typename Y3, typename Z3, typename W3,
typename X4, typename Y4, typename Z4, typename W4>
GLM_FUNC_DECL explicit tmat4x4(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL explicit tmat4x4(
tvec4<V1> const & v1,
tvec4<V2> const & v2,
tvec4<V3> const & v3,
tvec4<V4> const & v4);
// Matrix conversions
template <typename U>
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
// Accesses
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
GLM_FUNC_DECL tmat4x4<T> & operator= (tmat4x4<T> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator= (tmat4x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator+= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator-= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator*= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator/= (U s);
template <typename U>
GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator++ ();
GLM_FUNC_DECL tmat4x4<T> & operator-- ();
};
// Binary operators
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator+ (
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator+ (
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator+ (
tmat4x4<T> const & m1,
tmat4x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator- (
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator- (
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator- (
tmat4x4<T> const & m1,
tmat4x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator* (
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator* (
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat4x4<T>::col_type operator* (
tmat4x4<T> const & m,
typename tmat4x4<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat4x4<T>::row_type operator* (
typename tmat4x4<T>::col_type const & v,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat2x4<T> operator* (
tmat4x4<T> const & m1,
tmat2x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat3x4<T> operator* (
tmat4x4<T> const & m1,
tmat3x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator* (
tmat4x4<T> const & m1,
tmat4x4<T> const & m2);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator/ (
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator/ (
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL typename tmat4x4<T>::col_type operator/ (
tmat4x4<T> const & m,
typename tmat4x4<T>::row_type const & v);
template <typename T>
GLM_FUNC_DECL typename tmat4x4<T>::row_type operator/ (
typename tmat4x4<T>::col_type & v,
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> operator/ (
tmat4x4<T> const & m1,
tmat4x4<T> const & m2);
// Unary constant operators
template <typename T>
GLM_FUNC_DECL tmat4x4<T> const operator- (
tmat4x4<T> const & m);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> const operator-- (
tmat4x4<T> const & m, int);
template <typename T>
GLM_FUNC_DECL tmat4x4<T> const operator++ (
tmat4x4<T> const & m, int);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<lowp_float> lowp_mat4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<mediump_float> mediump_mat4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<highp_float> highp_mat4;
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<lowp_float> lowp_mat4x4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<mediump_float> mediump_mat4x4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tmat4x4<highp_float> highp_mat4x4;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_mat4x4.inl"
#endif//GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_mat4x4

893
Glm/core/type_mat4x4.inl

@ -0,0 +1,893 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_mat4x4.inl
/// @date 2005-01-27 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat4x4<T>::size_type tmat4x4<T>::length() const
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::col_size()
{
return 4;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::row_size()
{
return 4;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type &
tmat4x4<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return this->value[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type const &
tmat4x4<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4()
{
value_type Zero(0);
value_type One(1);
this->value[0] = col_type(One, Zero, Zero, Zero);
this->value[1] = col_type(Zero, One, Zero, Zero);
this->value[2] = col_type(Zero, Zero, One, Zero);
this->value[3] = col_type(Zero, Zero, Zero, One);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat4x4<T> const & m
)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
this->value[3] = m.value[3];
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero, Zero, Zero);
this->value[1] = col_type(Zero, s, Zero, Zero);
this->value[2] = col_type(Zero, Zero, s, Zero);
this->value[3] = col_type(Zero, Zero, Zero, s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3
)
{
this->value[0] = col_type(x0, y0, z0, w0);
this->value[1] = col_type(x1, y1, z1, w1);
this->value[2] = col_type(x2, y2, z2, w2);
this->value[3] = col_type(x3, y3, z3, w3);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
col_type const & v0,
col_type const & v1,
col_type const & v2,
col_type const & v3
)
{
this->value[0] = v0;
this->value[1] = v1;
this->value[2] = v2;
this->value[3] = v3;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat4x4<U> const & m
)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
//////////////////////////////////////
// Convertion constructors
template <typename T>
template <typename U>
GLM_FUNC_DECL tmat4x4<T>::tmat4x4
(
U const & s
)
{
GLM_STATIC_ASSERT(detail::type<U>::is_float || std::numeric_limits<U>::is_integer, "*mat4x4 constructor only takes float and integer types");
value_type const Zero(0);
this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
this->value[3] = tvec4<T>(Zero, Zero, Zero, value_type(s));
}
template <typename T>
template <
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,
typename X3, typename Y3, typename Z3, typename W3,
typename X4, typename Y4, typename Z4, typename W4>
GLM_FUNC_DECL tmat4x4<T>::tmat4x4
(
X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4
)
{
GLM_STATIC_ASSERT(detail::type<X1>::is_float || std::numeric_limits<X1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Y1>::is_float || std::numeric_limits<Y1>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Z1>::is_float || std::numeric_limits<Z1>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<W1>::is_float || std::numeric_limits<W1>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<X2>::is_float || std::numeric_limits<X2>::is_integer, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Y2>::is_float || std::numeric_limits<Y2>::is_integer, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Z2>::is_float || std::numeric_limits<Z2>::is_integer, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<W2>::is_float || std::numeric_limits<W2>::is_integer, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<X3>::is_float || std::numeric_limits<X3>::is_integer, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Y3>::is_float || std::numeric_limits<Y3>::is_integer, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Z3>::is_float || std::numeric_limits<Z3>::is_integer, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<W3>::is_float || std::numeric_limits<W3>::is_integer, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<X4>::is_float || std::numeric_limits<X4>::is_integer, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Y4>::is_float || std::numeric_limits<Y4>::is_integer, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<Z4>::is_float || std::numeric_limits<Z4>::is_integer, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<W4>::is_float || std::numeric_limits<W4>::is_integer, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4), value_type(w4));
}
template <typename T>
template <typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_DECL tmat4x4<T>::tmat4x4
(
tvec4<V1> const & v1,
tvec4<V2> const & v2,
tvec4<V3> const & v3,
tvec4<V4> const & v4
)
{
GLM_STATIC_ASSERT(detail::type<V1>::is_float || std::numeric_limits<V1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<V2>::is_float || std::numeric_limits<V2>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<V3>::is_float || std::numeric_limits<V3>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
GLM_STATIC_ASSERT(detail::type<V4>::is_float || std::numeric_limits<V4>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
this->value[0] = col_type(v1);
this->value[1] = col_type(v2);
this->value[2] = col_type(v3);
this->value[3] = col_type(v4);
}
//////////////////////////////////////
// Matrix convertion constructors
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat2x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat3x3<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(m[2], value_type(0));
this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat2x3<T> const & m
)
{
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat3x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
this->value[2] = col_type(m[2], detail::tvec2<T>(0));
this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat2x4<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = col_type(T(0));
this->value[3] = col_type(T(0), T(0), T(0), T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat4x2<T> const & m
)
{
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
this->value[2] = col_type(T(0));
this->value[3] = col_type(T(0), T(0), T(0), T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat3x4<T> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = col_type(T(0), T(0), T(0), T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
(
tmat4x3<T> const & m
)
{
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], T(0));
this->value[2] = col_type(m[2], T(0));
this->value[3] = col_type(m[3], T(1));
}
//////////////////////////////////////////////////////////////
// Operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator=
(
tmat4x4<T> const & m
)
{
//memcpy could be faster
//memcpy(&this->value, &m.value, 16 * sizeof(valType));
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator=
(
tmat4x4<U> const & m
)
{
//memcpy could be faster
//memcpy(&this->value, &m.value, 16 * sizeof(valType));
this->value[0] = m[0];
this->value[1] = m[1];
this->value[2] = m[2];
this->value[3] = m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= (U s)
{
this->value[0] += s;
this->value[1] += s;
this->value[2] += s;
this->value[3] += s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+=
(
tmat4x4<U> const & m
)
{
this->value[0] += m[0];
this->value[1] += m[1];
this->value[2] += m[2];
this->value[3] += m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= (U s)
{
this->value[0] -= s;
this->value[1] -= s;
this->value[2] -= s;
this->value[3] -= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-=
(
tmat4x4<U> const & m
)
{
this->value[0] -= m[0];
this->value[1] -= m[1];
this->value[2] -= m[2];
this->value[3] -= m[3];
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= (U s)
{
this->value[0] *= s;
this->value[1] *= s;
this->value[2] *= s;
this->value[3] *= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*=
(
tmat4x4<U> const & m
)
{
return (*this = *this * m);
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= (U s)
{
this->value[0] /= s;
this->value[1] /= s;
this->value[2] /= s;
this->value[3] /= s;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/=
(
tmat4x4<U> const & m
)
{
return (*this = *this / m);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator++ ()
{
++this->value[0];
++this->value[1];
++this->value[2];
++this->value[3];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-- ()
{
--this->value[0];
--this->value[1];
--this->value[2];
--this->value[3];
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> tmat4x4<T>::_inverse() const
{
// Calculate all mat2 determinants
value_type SubFactor00 = this->value[2][2] * this->value[3][3] - this->value[3][2] * this->value[2][3];
value_type SubFactor01 = this->value[2][1] * this->value[3][3] - this->value[3][1] * this->value[2][3];
value_type SubFactor02 = this->value[2][1] * this->value[3][2] - this->value[3][1] * this->value[2][2];
value_type SubFactor03 = this->value[2][0] * this->value[3][3] - this->value[3][0] * this->value[2][3];
value_type SubFactor04 = this->value[2][0] * this->value[3][2] - this->value[3][0] * this->value[2][2];
value_type SubFactor05 = this->value[2][0] * this->value[3][1] - this->value[3][0] * this->value[2][1];
value_type SubFactor06 = this->value[1][2] * this->value[3][3] - this->value[3][2] * this->value[1][3];
value_type SubFactor07 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
value_type SubFactor08 = this->value[1][1] * this->value[3][2] - this->value[3][1] * this->value[1][2];
value_type SubFactor09 = this->value[1][0] * this->value[3][3] - this->value[3][0] * this->value[1][3];
value_type SubFactor10 = this->value[1][0] * this->value[3][2] - this->value[3][0] * this->value[1][2];
value_type SubFactor11 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
value_type SubFactor12 = this->value[1][0] * this->value[3][1] - this->value[3][0] * this->value[1][1];
value_type SubFactor13 = this->value[1][2] * this->value[2][3] - this->value[2][2] * this->value[1][3];
value_type SubFactor14 = this->value[1][1] * this->value[2][3] - this->value[2][1] * this->value[1][3];
value_type SubFactor15 = this->value[1][1] * this->value[2][2] - this->value[2][1] * this->value[1][2];
value_type SubFactor16 = this->value[1][0] * this->value[2][3] - this->value[2][0] * this->value[1][3];
value_type SubFactor17 = this->value[1][0] * this->value[2][2] - this->value[2][0] * this->value[1][2];
value_type SubFactor18 = this->value[1][0] * this->value[2][1] - this->value[2][0] * this->value[1][1];
/*
tmat4x4<T> Inverse(
+ (this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02),
- (this->value[1][0] * SubFactor00 - this->value[1][2] * SubFactor03 + this->value[1][3] * SubFactor04),
+ (this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05),
- (this->value[1][0] * SubFactor02 - this->value[1][1] * SubFactor04 + this->value[1][2] * SubFactor05),
- (this->value[0][1] * SubFactor00 - this->value[0][2] * SubFactor01 + this->value[0][3] * SubFactor02),
+ (this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04),
- (this->value[0][0] * SubFactor01 - this->value[0][1] * SubFactor03 + this->value[0][3] * SubFactor05),
+ (this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05),
+ (this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08),
- (this->value[0][0] * SubFactor06 - this->value[0][2] * SubFactor09 + this->value[0][3] * SubFactor10),
+ (this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12),
- (this->value[0][0] * SubFactor08 - this->value[0][1] * SubFactor10 + this->value[0][2] * SubFactor12),
- (this->value[0][1] * SubFactor13 - this->value[0][2] * SubFactor14 + this->value[0][3] * SubFactor15),
+ (this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17),
- (this->value[0][0] * SubFactor14 - this->value[0][1] * SubFactor16 + this->value[0][3] * SubFactor18),
+ (this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18));
*/
tmat4x4<T> Inverse(
+ this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02,
- this->value[1][0] * SubFactor00 + this->value[1][2] * SubFactor03 - this->value[1][3] * SubFactor04,
+ this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05,
- this->value[1][0] * SubFactor02 + this->value[1][1] * SubFactor04 - this->value[1][2] * SubFactor05,
- this->value[0][1] * SubFactor00 + this->value[0][2] * SubFactor01 - this->value[0][3] * SubFactor02,
+ this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04,
- this->value[0][0] * SubFactor01 + this->value[0][1] * SubFactor03 - this->value[0][3] * SubFactor05,
+ this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05,
+ this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08,
- this->value[0][0] * SubFactor06 + this->value[0][2] * SubFactor09 - this->value[0][3] * SubFactor10,
+ this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12,
- this->value[0][0] * SubFactor08 + this->value[0][1] * SubFactor10 - this->value[0][2] * SubFactor12,
- this->value[0][1] * SubFactor13 + this->value[0][2] * SubFactor14 - this->value[0][3] * SubFactor15,
+ this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17,
- this->value[0][0] * SubFactor14 + this->value[0][1] * SubFactor16 - this->value[0][3] * SubFactor18,
+ this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18);
value_type Determinant =
+ this->value[0][0] * Inverse[0][0]
+ this->value[0][1] * Inverse[1][0]
+ this->value[0][2] * Inverse[2][0]
+ this->value[0][3] * Inverse[3][0];
Inverse /= Determinant;
return Inverse;
}
// Binary operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator+
(
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s
)
{
return tmat4x4<T>(
m[0] + s,
m[1] + s,
m[2] + s,
m[3] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator+
(
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m
)
{
return tmat4x4<T>(
m[0] + s,
m[1] + s,
m[2] + s,
m[3] + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator+
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
return tmat4x4<T>(
m1[0] + m2[0],
m1[1] + m2[1],
m1[2] + m2[2],
m1[3] + m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator-
(
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s
)
{
return tmat4x4<T>(
m[0] - s,
m[1] - s,
m[2] - s,
m[3] - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator-
(
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m
)
{
return tmat4x4<T>(
s - m[0],
s - m[1],
s - m[2],
s - m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator-
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
return tmat4x4<T>(
m1[0] - m2[0],
m1[1] - m2[1],
m1[2] - m2[2],
m1[3] - m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator*
(
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s
)
{
return tmat4x4<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator*
(
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m
)
{
return tmat4x4<T>(
m[0] * s,
m[1] * s,
m[2] * s,
m[3] * s);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator*
(
tmat4x4<T> const & m,
typename tmat4x4<T>::row_type const & v
)
{
return typename tmat4x4<T>::col_type(
m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w,
m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z + m[3][3] * v.w);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator*
(
typename tmat4x4<T>::col_type const & v,
tmat4x4<T> const & m
)
{
return typename tmat4x4<T>::row_type(
m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w,
m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T> operator*
(
tmat4x4<T> const & m1,
tmat2x4<T> const & m2
)
{
return tmat2x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T> operator*
(
tmat4x4<T> const & m1,
tmat3x4<T> const & m2
)
{
return tmat3x4<T>(
m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator*
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
typename tmat4x4<T>::col_type const SrcA0 = m1[0];
typename tmat4x4<T>::col_type const SrcA1 = m1[1];
typename tmat4x4<T>::col_type const SrcA2 = m1[2];
typename tmat4x4<T>::col_type const SrcA3 = m1[3];
typename tmat4x4<T>::col_type const SrcB0 = m2[0];
typename tmat4x4<T>::col_type const SrcB1 = m2[1];
typename tmat4x4<T>::col_type const SrcB2 = m2[2];
typename tmat4x4<T>::col_type const SrcB3 = m2[3];
tmat4x4<T> Result(tmat4x4<T>::null);
Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator/
(
tmat4x4<T> const & m,
typename tmat4x4<T>::value_type const & s
)
{
return tmat4x4<T>(
m[0] / s,
m[1] / s,
m[2] / s,
m[3] / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator/
(
typename tmat4x4<T>::value_type const & s,
tmat4x4<T> const & m
)
{
return tmat4x4<T>(
s / m[0],
s / m[1],
s / m[2],
s / m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator/
(
tmat4x4<T> const & m,
typename tmat4x4<T>::row_type const & v
)
{
return m._inverse() * v;
}
template <typename T>
GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator/
(
typename tmat4x4<T>::col_type const & v,
tmat4x4<T> const & m
)
{
return v * m._inverse();
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> operator/
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
return m1 * m2._inverse();
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> const operator-
(
tmat4x4<T> const & m
)
{
return tmat4x4<T>(
-m[0],
-m[1],
-m[2],
-m[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> const operator++
(
tmat4x4<T> const & m,
int
)
{
return tmat4x4<T>(
m[0] + typename tmat4x4<T>::value_type(1),
m[1] + typename tmat4x4<T>::value_type(1),
m[2] + typename tmat4x4<T>::value_type(1),
m[3] + typename tmat4x4<T>::value_type(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T> const operator--
(
tmat4x4<T> const & m,
int
)
{
return tmat4x4<T>(
m[0] - typename tmat4x4<T>::value_type(1),
m[1] - typename tmat4x4<T>::value_type(1),
m[2] - typename tmat4x4<T>::value_type(1),
m[3] - typename tmat4x4<T>::value_type(1));
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tmat4x4<T> const & m1,
tmat4x4<T> const & m2
)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
}
} //namespace detail
} //namespace glm

43
Glm/core/type_size.hpp

@ -0,0 +1,43 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_size.hpp
/// @date 2008-10-05 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_size
#define glm_core_type_size
#include <cstdlib>
namespace glm{
namespace detail
{
//typedef std::size_t size_t;
typedef int sizeType;
}//namespace detail
}//namespace glm
#endif//glm_core_type_size

41
Glm/core/type_vec.hpp

@ -0,0 +1,41 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec.hpp
/// @date 2010-01-26 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_vec
#define glm_core_type_vec
#include "type_gentype.hpp"
namespace glm{
namespace detail
{
}//namespace detail
}//namespace glm
#endif//glm_core_type_vec

27
Glm/core/type_vec.inl

@ -0,0 +1,27 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec.inl
/// @date 2011-06-15 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////

212
Glm/core/type_vec1.hpp

@ -0,0 +1,212 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec1.hpp
/// @date 2008-08-25 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_gentype1
#define glm_core_type_gentype1
#include "type_vec.hpp"
#include "type_float.hpp"
#include "type_int.hpp"
#include "type_size.hpp"
#include "_swizzle.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tref1;
template <typename T> struct tref2;
template <typename T> struct tref3;
template <typename T> struct tref4;
template <typename T> struct tvec1;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T>
struct tvec1
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec1<T> type;
typedef tvec1<bool> bool_type;
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
//////////////////////////////////////
// Data
# if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
value_type x;
# else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
union {value_type x, r, s;};
# endif//GLM_COMPONENT
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec1();
GLM_FUNC_DECL tvec1(tvec1<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec1(
ctor);
GLM_FUNC_DECL explicit tvec1(
value_type const & s);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec1(tref1<T> const & r);
//////////////////////////////////////
// Convertion 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 tvec1(U const & s);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator= (tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator+=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator-=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator*=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator/=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<U> const & v);
GLM_FUNC_DECL tvec1<T> & operator++();
GLM_FUNC_DECL tvec1<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator%=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator&=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator|=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator^=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator<<=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator>>=(U const & s);
template <typename U>
GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<U> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref1<T> swizzle(comp X);
};
template <typename T>
struct tref1
{
GLM_FUNC_DECL tref1(T & x);
GLM_FUNC_DECL tref1(tref1<T> const & r);
GLM_FUNC_DECL tref1(tvec1<T> const & v);
GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
T& x;
};
GLM_DETAIL_IS_VECTOR(tvec1);
typedef detail::tvec1<highp_float> highp_vec1_t;
typedef detail::tvec1<mediump_float> mediump_vec1_t;
typedef detail::tvec1<lowp_float> lowp_vec1_t;
typedef detail::tvec1<highp_int> highp_ivec1_t;
typedef detail::tvec1<mediump_int> mediump_ivec1_t;
typedef detail::tvec1<lowp_int> lowp_ivec1_t;
typedef detail::tvec1<highp_uint> highp_uvec1_t;
typedef detail::tvec1<mediump_uint> mediump_uvec1_t;
typedef detail::tvec1<lowp_uint> lowp_uvec1_t;
}//namespace detail
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_vec1.inl"
#endif//GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_gentype1

928
Glm/core/type_vec1.inl

@ -0,0 +1,928 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec1.inl
/// @date 2008-08-25 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec1<T>::size_type tvec1<T>::length() const
{
return 1;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tvec1<T>::value_type & tvec1<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return (&x)[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tvec1<T>::value_type const & tvec1<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return (&x)[i];
}
//////////////////////////////////////
// Implicit basic constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1() :
x(value_type(0))
{}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
tvec1<T> const & v
) :
x(v.x)
{}
//////////////////////////////////////
// Explicit basic constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
value_type const & s
) :
x(s)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
tref1<T> const & r
) :
x(r.x)
{}
//////////////////////////////////////
// Convertion scalar constructors
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
U const & s
) :
x(value_type(s))
{}
//////////////////////////////////////
// Convertion vector constructors
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
tvec2<U> const & v
) :
x(value_type(v.x))
{}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
tvec3<U> const & v
) :
x(value_type(v.x))
{}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T>::tvec1
(
tvec4<U> const & v
) :
x(value_type(v.x))
{}
//////////////////////////////////////
// Unary arithmetic operators
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
(
tvec1<T> const & v
)
{
this->x = v.x;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
(
tvec1<U> const & v
)
{
this->x = T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
(
U const & s
)
{
this->x += T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
(
tvec1<U> const & v
)
{
this->x += T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
(
U const & s
)
{
this->x -= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
(
tvec1<U> const & v
)
{
this->x -= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
(
U const & s
)
{
this->x *= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
(
tvec1<U> const & v
)
{
this->x *= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
(
U const & s
)
{
this->x /= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
(
tvec1<U> const & v
)
{
this->x /= T(v.x);
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator++()
{
++this->x;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator--()
{
--this->x;
return *this;
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return (v1.x == v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return (v1.x != v2.x);
}
//////////////////////////////////////
// Unary bit operators
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
(
U const & s
)
{
this->x %= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
(
tvec1<U> const & v
)
{
this->x %= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
(
U const & s
)
{
this->x &= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
(
tvec1<U> const & v
)
{
this->x &= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
(
U const & s
)
{
this->x |= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
(
tvec1<U> const & v
)
{
this->x |= U(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
(
U const & s
)
{
this->x ^= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
(
tvec1<U> const & v
)
{
this->x ^= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
(
U const & s
)
{
this->x <<= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
(
tvec1<U> const & v
)
{
this->x <<= T(v.x);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
(
U const & s
)
{
this->x >>= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
(
tvec1<U> const & v
)
{
this->x >>= T(v.x);
return *this;
}
//////////////////////////////////////
// Swizzle operators
template <typename T>
GLM_FUNC_QUALIFIER T
tvec1<T>::swizzle(comp x) const
{
return (*this)[x];
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>
tvec1<T>::swizzle
(
comp x,
comp y
) const
{
return tvec2<T>(
(*this)[x],
(*this)[y]);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec3<T>
tvec1<T>::swizzle
(
comp x,
comp y,
comp z
) const
{
return tvec3<T>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec4<T>
tvec1<T>::swizzle
(
comp x,
comp y,
comp z,
comp w
) const
{
return tvec4<T>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T>
GLM_FUNC_QUALIFIER tref1<T>
tvec1<T>::swizzle
(
comp x
)
{
return tref1<T>(
(*this)[x]);
}
//////////////////////////////////////
// Binary arithmetic operators
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator+
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x + s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator+
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s + v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator+
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x + v2.x);
}
//operator-
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator-
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x - s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator-
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s - v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator-
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x - v2.x);
}
//operator*
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator*
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x * s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator*
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s * v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator*
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x * v2.x);
}
//operator/
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator/
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x / s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator/
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s / v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator/
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x / v2.x);
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator-
(
tvec1<T> const & v
)
{
return tvec1<T>(
-v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator++
(
tvec1<T> const & v,
int
)
{
return tvec1<T>(
v.x + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator--
(
tvec1<T> const & v,
int
)
{
return tvec1<T>(
v.x - T(1));
}
//////////////////////////////////////
// Binary bit operators
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator%
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x % s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator%
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s % v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator%
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x % v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator&
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x & s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator&
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s & v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator&
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x & v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator|
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x | s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator|
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s | v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator|
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x | v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator^
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x ^ s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator^
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s ^ v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator^
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x ^ v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator<<
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x << s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator<<
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s << v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator<<
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x << v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator>>
(
tvec1<T> const & v,
typename tvec1<T>::value_type const & s
)
{
return tvec1<T>(
v.x >> s);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator>>
(
typename tvec1<T>::value_type const & s,
tvec1<T> const & v
)
{
return tvec1<T>(
s >> v.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator>>
(
tvec1<T> const & v1,
tvec1<T> const & v2
)
{
return tvec1<T>(
v1.x >> v2.x);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec1<T> operator~
(
tvec1<T> const & v
)
{
return tvec1<T>(
~v.x);
}
//////////////////////////////////////
// tref definition
template <typename T>
GLM_FUNC_QUALIFIER tref1<T>::tref1
(
T & x
) :
x(x)
{}
template <typename T>
GLM_FUNC_QUALIFIER tref1<T>::tref1
(
tref1<T> const & r
) :
x(r.x)
{}
template <typename T>
GLM_FUNC_QUALIFIER tref1<T>::tref1
(
tvec1<T> const & v
) :
x(v.x)
{}
template <typename T>
GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator=
(
tref1<T> const & r
)
{
x = r.x;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator=
(
tvec1<T> const & v
)
{
x = v.x;
return *this;
}
}//namespace detail
}//namespace glm

317
Glm/core/type_vec2.hpp

@ -0,0 +1,317 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec2.hpp
/// @date 2008-08-18 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_gentype2
#define glm_core_type_gentype2
#include "type_vec.hpp"
#include "type_float.hpp"
#include "type_int.hpp"
#include "type_size.hpp"
#include "_swizzle.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tref2;
template <typename T> struct tref3;
template <typename T> struct tref4;
template <typename T> struct tvec3;
template <typename T> struct tvec4;
template <typename T>
struct tvec2
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec2<T> type;
typedef tvec2<bool> bool_type;
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
//////////////////////////////////////
// Data
# if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
union
{
struct{value_type x, y;};
struct{value_type r, g;};
struct{value_type s, t;};
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y)
_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g)
_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t)
_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y)
_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g)
_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t)
_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y)
_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g)
_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t)
# endif//(defined(GLM_SWIZZLE))
};
# elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
union {value_type x, r, s;};
union {value_type y, g, t;};
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, detail::tvec2, detail::tref2)
GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE))
# else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
value_type x, y;
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y)
GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y)
# endif//(defined(GLM_SWIZZLE))
# endif//GLM_COMPONENT
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec2();
GLM_FUNC_DECL tvec2(tvec2<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec2(
ctor);
GLM_FUNC_DECL explicit tvec2(
value_type const & s);
GLM_FUNC_DECL explicit tvec2(
value_type const & s1,
value_type const & s2);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec2(tref2<T> const & r);
template <int E0, int E1>
GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T>,E0,E1,-1,-2>& that)
{
*this = that();
}
//////////////////////////////////////
// Convertion 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(
U const & x,
V const & y);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator++();
GLM_FUNC_DECL tvec2<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
};
template <typename T>
struct tref2
{
GLM_FUNC_DECL tref2(T & x, T & y);
GLM_FUNC_DECL tref2(tref2<T> const & r);
GLM_FUNC_DECL explicit tref2(tvec2<T> const & v);
GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
GLM_FUNC_DECL tvec2<T> operator() ();
T & x;
T & y;
};
GLM_DETAIL_IS_VECTOR(tvec2);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 2 components vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<highp_float> highp_vec2;
/// 2 components vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<mediump_float> mediump_vec2;
/// 2 components vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<lowp_float> lowp_vec2;
/// 2 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<highp_int> highp_ivec2;
/// 2 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<mediump_int> mediump_ivec2;
/// 2 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<lowp_int> lowp_ivec2;
/// 2 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<highp_uint> highp_uvec2;
/// 2 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<mediump_uint> mediump_uvec2;
/// 2 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<lowp_uint> lowp_uvec2;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_vec2.inl"
#endif//GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_gentype2

998
Glm/core/type_vec2.inl

@ -0,0 +1,998 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_tvec2.inl
/// @date 2008-08-18 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec2<T>::size_type tvec2<T>::length() const
{
return 2;
}
//////////////////////////////////////
// Accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tvec2<T>::value_type &
tvec2<T>::operator[]
(
size_type i
)
{
assert(i < this->length());
return (&x)[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tvec2<T>::value_type const &
tvec2<T>::operator[]
(
size_type i
) const
{
assert(i < this->length());
return (&x)[i];
}
//////////////////////////////////////
// Implicit basic constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2() :
x(value_type(0)),
y(value_type(0))
{}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
ctor
)
{}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
tvec2<T> const & v
) :
x(v.x),
y(v.y)
{}
//////////////////////////////////////
// Explicit basic constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
value_type const & s
) :
x(s),
y(s)
{}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
value_type const & s1,
value_type const & s2
) :
x(s1),
y(s2)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
tref2<T> const & r
) :
x(r.x),
y(r.y)
{}
//////////////////////////////////////
// Convertion scalar constructors
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
U const & x
) :
x(value_type(x)),
y(value_type(x))
{}
template <typename T>
template <typename U, typename V>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
U const & a,
V const & b
) :
x(value_type(a)),
y(value_type(b))
{}
//////////////////////////////////////
// Convertion vector constructors
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
tvec2<U> const & v
) :
x(value_type(v.x)),
y(value_type(v.y))
{}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
tvec3<U> const & v
) :
x(value_type(v.x)),
y(value_type(v.y))
{}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T>::tvec2
(
tvec4<U> const & v
) :
x(value_type(v.x)),
y(value_type(v.y))
{}
//////////////////////////////////////
// Unary arithmetic operators
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator=
(
tvec2<T> const & v
)
{
this->x = v.x;
this->y = v.y;
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator=
(
tvec2<U> const & v
)
{
this->x = T(v.x);
this->y = T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=(U s)
{
this->x += T(s);
this->y += T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
(
tvec2<U> const & v
)
{
this->x += T(v.x);
this->y += T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=(U s)
{
this->x -= T(s);
this->y -= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
(
tvec2<U> const & v
)
{
this->x -= T(v.x);
this->y -= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=(U s)
{
this->x *= T(s);
this->y *= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
(
tvec2<U> const & v
)
{
this->x *= T(v.x);
this->y *= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=(U s)
{
this->x /= T(s);
this->y /= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
(
tvec2<U> const & v
)
{
this->x /= T(v.x);
this->y /= T(v.y);
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator++()
{
++this->x;
++this->y;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator--()
{
--this->x;
--this->y;
return *this;
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return (v1.x == v2.x) && (v1.y == v2.y);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return (v1.x != v2.x) || (v1.y != v2.y);
}
//////////////////////////////////////
// Unary bit operators
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=(U s)
{
this->x %= T(s);
this->y %= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
(
tvec2<U> const & v
)
{
this->x %= T(v.x);
this->y %= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=(U s)
{
this->x &= T(s);
this->y &= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
(
tvec2<U> const & v
)
{
this->x &= T(v.x);
this->y &= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=(U s)
{
this->x |= T(s);
this->y |= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
(
tvec2<U> const & v
)
{
this->x |= T(v.x);
this->y |= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=(U s)
{
this->x ^= T(s);
this->y ^= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
(
tvec2<U> const & v
)
{
this->x ^= T(v.x);
this->y ^= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=(U s)
{
this->x <<= T(s);
this->y <<= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
(
tvec2<U> const & v
)
{
this->x <<= T(v.x);
this->y <<= T(v.y);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=(U s)
{
this->x >>= T(s);
this->y >>= T(s);
return *this;
}
template <typename T>
template <typename U>
GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
(
tvec2<U> const & v
)
{
this->x >>= T(v.x);
this->y >>= T(v.y);
return *this;
}
//////////////////////////////////////
// Swizzle operators
template <typename T>
GLM_FUNC_QUALIFIER typename tvec2<T>::value_type tvec2<T>::swizzle
(
comp x
) const
{
return (*this)[x];
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> tvec2<T>::swizzle
(
comp x,
comp y
) const
{
return tvec2<T>(
(*this)[x],
(*this)[y]);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec3<T> tvec2<T>::swizzle
(
comp x,
comp y,
comp z
) const
{
return tvec3<T>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec4<T> tvec2<T>::swizzle
(
comp x,
comp y,
comp z,
comp w
) const
{
return tvec4<T>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T>
GLM_FUNC_QUALIFIER tref2<T> tvec2<T>::swizzle
(
comp x,
comp y
)
{
return tref2<T>(
(*this)[x],
(*this)[y]);
}
//////////////////////////////////////
// Binary arithmetic operators
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator+
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x + T(s),
v.y + T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator+
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) + v.x,
T(s) + v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator+
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x + T(v2.x),
v1.y + T(v2.y));
}
//operator-
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator-
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x - T(s),
v.y - T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator-
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) - v.x,
T(s) - v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator-
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x - T(v2.x),
v1.y - T(v2.y));
}
//operator*
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator*
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x * T(s),
v.y * T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator*
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) * v.x,
T(s) * v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator*
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x * T(v2.x),
v1.y * T(v2.y));
}
//operator/
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator/
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x / T(s),
v.y / T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator/
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) / v.x,
T(s) / v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator/
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x / T(v2.x),
v1.y / T(v2.y));
}
// Unary constant operators
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator-
(
tvec2<T> const & v
)
{
return tvec2<T>(
-v.x,
-v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator++
(
tvec2<T> const & v,
int
)
{
return tvec2<T>(
v.x + T(1),
v.y + T(1));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator--
(
tvec2<T> const & v,
int
)
{
return tvec2<T>(
v.x - T(1),
v.y - T(1));
}
//////////////////////////////////////
// Binary bit operators
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator%
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x % T(s),
v.y % T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator%
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) % v.x,
T(s) % v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator%
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x % T(v2.x),
v1.y % T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator&
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x & T(s),
v.y & T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator&
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) & v.x,
T(s) & v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator&
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x & T(v2.x),
v1.y & T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator|
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x | T(s),
v.y | T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator|
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) | v.x,
T(s) | v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator|
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x | T(v2.x),
v1.y | T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator^
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x ^ T(s),
v.y ^ T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator^
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) ^ v.x,
T(s) ^ v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator^
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x ^ T(v2.x),
v1.y ^ T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator<<
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x << T(s),
v.y << T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator<<
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
s << T(v.x),
s << T(v.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator<<
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x << T(v2.x),
v1.y << T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator>>
(
tvec2<T> const & v,
T const & s
)
{
return tvec2<T>(
v.x >> T(s),
v.y >> T(s));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator>>
(
T const & s,
tvec2<T> const & v
)
{
return tvec2<T>(
T(s) >> v.x,
T(s) >> v.y);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator>>
(
tvec2<T> const & v1,
tvec2<T> const & v2
)
{
return tvec2<T>(
v1.x >> T(v2.x),
v1.y >> T(v2.y));
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> operator~
(
tvec2<T> const & v
)
{
return tvec2<T>(
~v.x,
~v.y);
}
//////////////////////////////////////
// tref definition
template <typename T>
tref2<T>::tref2
(
T & x,
T & y
) :
x(x),
y(y)
{}
template <typename T>
tref2<T>::tref2
(
tref2<T> const & r
) :
x(r.x),
y(r.y)
{}
template <typename T>
tref2<T>::tref2
(
tvec2<T> const & v
) :
x(v.x),
y(v.y)
{}
template <typename T>
tref2<T>& tref2<T>::operator=
(
tref2<T> const & r
)
{
x = r.x;
y = r.y;
return *this;
}
template <typename T>
tref2<T>& tref2<T>::operator=
(
tvec2<T> const & v
)
{
x = v.x;
y = v.y;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T> tref2<T>::operator() ()
{
return tvec2<T>(this->x, this->y);
}
}//namespace detail
}//namespace glm

342
Glm/core/type_vec3.hpp

@ -0,0 +1,342 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec3.hpp
/// @date 2008-08-22 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_gentype3
#define glm_core_type_gentype3
#include "type_vec.hpp"
#include "type_float.hpp"
#include "type_int.hpp"
#include "type_size.hpp"
#include "_swizzle.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tref2;
template <typename T> struct tref3;
template <typename T> struct tref4;
template <typename T> struct tvec2;
template <typename T> struct tvec4;
template <typename T>
struct tvec3
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec3<T> type;
typedef tvec3<bool> bool_type;
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
//////////////////////////////////////
// Data
# if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
union
{
struct{value_type x, y, z;};
struct{value_type r, g, b;};
struct{value_type s, t, p;};
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z)
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b)
_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b)
_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b)
_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p)
# endif//(defined(GLM_SWIZZLE))
};
# elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
union {value_type x, r, s;};
union {value_type y, g, t;};
union {value_type z, b, p;};
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, detail::tvec3, detail::tref2, detail::tref3)
GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE))
# else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
value_type x, y, z;
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z)
GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z)
# endif//(defined(GLM_SWIZZLE))
# endif//GLM_COMPONENT
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec3();
GLM_FUNC_DECL tvec3(tvec3<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec3(
ctor);
GLM_FUNC_DECL explicit tvec3(
value_type const & s);
GLM_FUNC_DECL explicit tvec3(
value_type const & s1,
value_type const & s2,
value_type const & s3);
//////////////////////////////////////
// Convertion 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);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec3(tref3<T> const & r);
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(tref2<A> const & v, B const & s);
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B> const & v);
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & that)
{
*this = that();
}
template <int E0, int E1>
GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
{
*this = tvec3<T>(v(), s);
}
template <int E0, int E1>
GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
{
*this = tvec3<T>(s, v());
}
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator++();
GLM_FUNC_DECL tvec3<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
};
template <typename T>
struct tref3
{
GLM_FUNC_DECL tref3(T & x, T & y, T & z);
GLM_FUNC_DECL tref3(tref3<T> const & r);
GLM_FUNC_DECL explicit tref3(tvec3<T> const & v);
GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
GLM_FUNC_DECL tvec3<T> operator() ();
T & x;
T & y;
T & z;
};
GLM_DETAIL_IS_VECTOR(tvec3);
} //namespace detail
/// @addtogroup core_precision
/// @{
/// 3 components vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<highp_float> highp_vec3;
/// 3 components vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<mediump_float> mediump_vec3;
/// 3 components vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<lowp_float> lowp_vec3;
/// 3 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<highp_int> highp_ivec3;
/// 3 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<mediump_int> mediump_ivec3;
/// 3 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<lowp_int> lowp_ivec3;
/// 3 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<highp_uint> highp_uvec3;
/// 3 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<mediump_uint> mediump_uvec3;
/// 3 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<lowp_uint> lowp_uvec3;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_vec3.inl"
#endif//GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_gentype3

1122
Glm/core/type_vec3.inl
File diff suppressed because it is too large
View File

399
Glm/core/type_vec4.hpp

@ -0,0 +1,399 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/core/type_vec4.hpp
/// @date 2008-08-22 / 2011-06-15
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_core_type_gentype4
#define glm_core_type_gentype4
#include "type_vec.hpp"
#include "type_float.hpp"
#include "type_int.hpp"
#include "type_size.hpp"
#include "_swizzle.hpp"
namespace glm{
namespace detail
{
template <typename T> struct tref2;
template <typename T> struct tref3;
template <typename T> struct tref4;
template <typename T> struct tvec2;
template <typename T> struct tvec3;
template <typename T>
struct tvec4
{
enum ctor{null};
typedef T value_type;
typedef std::size_t size_type;
typedef tvec4<T> type;
typedef tvec4<bool> bool_type;
GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
//////////////////////////////////////
// Data
# if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
union
{
struct{value_type x, y, z, w;};
struct{value_type r, g, b, a;};
struct{value_type s, t, p, q;};
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w)
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a)
_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a)
_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a)
_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q)
# endif//(defined(GLM_SWIZZLE))
};
# elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
union {value_type x, r, s;};
union {value_type y, g, t;};
union {value_type z, b, p;};
union {value_type w, a, q;};
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE))
# else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
value_type x, y, z, w;
# if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
# endif//(defined(GLM_SWIZZLE))
# endif//GLM_COMPONENT
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec4();
GLM_FUNC_DECL tvec4(type const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec4(
ctor);
GLM_FUNC_DECL explicit tvec4(
value_type const & s);
GLM_FUNC_DECL explicit tvec4(
value_type const & s0,
value_type const & s1,
value_type const & s2,
value_type const & s3);
//////////////////////////////////////
// Convertion 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(
A const & x,
B const & y,
C const & z,
D const & w);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
{
*this = that();
}
template <int E0, int E1, int F0, int F1>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T>, F0, F1, -1, -2> const & u)
{
*this = tvec4<T>(v(), u());
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
{
*this = tvec4<T>(x, y, v());
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
{
*this = tvec4<T>(x, v(), w);
}
template <int E0, int E1>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
{
*this = tvec4<T>(v(), z, w);
}
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
{
*this = tvec4<T>(v(), w);
}
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
{
*this = tvec4<T>(x, v());
}
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec4(tref4<T> const & r);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator+=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator-=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator*=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator/=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator++();
GLM_FUNC_DECL tvec4<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator%= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator&= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator|= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator^= (U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator<<=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator>>=(U s);
template <typename U>
GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
};
template <typename T>
struct tref4
{
GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
GLM_FUNC_DECL tref4(tref4<T> const & r);
GLM_FUNC_DECL explicit tref4(tvec4<T> const & v);
GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
GLM_FUNC_DECL tvec4<T> operator() ();
T & x;
T & y;
T & z;
T & w;
};
GLM_DETAIL_IS_VECTOR(tvec4);
}//namespace detail
/// @addtogroup core_precision
/// @{
/// 4 components vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<highp_float> highp_vec4;
/// 4 components vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<mediump_float> mediump_vec4;
/// 4 components vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<lowp_float> lowp_vec4;
/// 4 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<highp_int> highp_ivec4;
/// 4 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<mediump_int> mediump_ivec4;
/// 4 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<lowp_int> lowp_ivec4;
/// 4 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<highp_uint> highp_uvec4;
/// 4 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<mediump_uint> mediump_uvec4;
/// 4 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<lowp_uint> lowp_uvec4;
/// @}
}//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE
#include "type_vec4.inl"
#endif//GLM_EXTERNAL_TEMPLATE
#endif//glm_core_type_gentype4

1348
Glm/core/type_vec4.inl
File diff suppressed because it is too large
View File

145
Glm/ext.hpp

@ -0,0 +1,145 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @file glm/glm.hpp
/// @date 2009-05-01 / 2011-05-16
/// @author Christophe Riccio
///
/// @ref core (Dependence)
///
/// @defgroup gtc GTC Extensions (Stable)
///
/// @brief Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.
///
/// GTC extensions aim to be stable.
///
/// Even if it's highly unrecommended, it's possible to include all the extensions at once by
/// including <glm/ext.hpp>. Otherwise, each extension needs to be included a specific file.
///
/// @defgroup gtx GTX Extensions (Experimental)
///
/// @brief Functions and types that the GLSL specification doesn't define, but
/// useful to have for a C++ program.
///
/// Experimental extensions are useful functions and types, but the development of
/// their API and functionality is not necessarily stable. They can change
/// substantially between versions. Backwards compatibility is not much of an issue
/// for them.
///
/// Even if it's highly unrecommended, it's possible to include all the extensions
/// at once by including <glm/ext.hpp>. Otherwise, each extension needs to be
/// included a specific file.
///
/// @defgroup virtrev VIRTREV Extensions
///
/// @brief Extensions develop and maintain by Mathieu [matrem] Roumillac
/// (http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showprofile&User=22660).
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_ext
#define glm_ext
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
# define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
# pragma message("GLM: All extensions included (not recommanded)")
#endif//GLM_MESSAGES
#include "./gtc/constants.hpp"
#include "./gtc/epsilon.hpp"
#include "./gtc/half_float.hpp"
#include "./gtc/matrix_access.hpp"
#include "./gtc/matrix_integer.hpp"
#include "./gtc/matrix_inverse.hpp"
#include "./gtc/matrix_transform.hpp"
#include "./gtc/noise.hpp"
#include "./gtc/quaternion.hpp"
#include "./gtc/random.hpp"
#include "./gtc/reciprocal.hpp"
#include "./gtc/swizzle.hpp"
#include "./gtc/type_precision.hpp"
#include "./gtc/type_ptr.hpp"
#include "./gtc/ulp.hpp"
#include "./gtx/associated_min_max.hpp"
#include "./gtx/bit.hpp"
#include "./gtx/closest_point.hpp"
#include "./gtx/color_cast.hpp"
#include "./gtx/color_space.hpp"
#include "./gtx/color_space_YCoCg.hpp"
#include "./gtx/compatibility.hpp"
#include "./gtx/component_wise.hpp"
#include "./gtx/euler_angles.hpp"
#include "./gtx/extend.hpp"
#include "./gtx/extented_min_max.hpp"
#include "./gtx/fast_exponential.hpp"
#include "./gtx/fast_square_root.hpp"
#include "./gtx/fast_trigonometry.hpp"
#include "./gtx/gradient_paint.hpp"
#include "./gtx/handed_coordinate_space.hpp"
#include "./gtx/inertia.hpp"
#include "./gtx/int_10_10_10_2.hpp"
#include "./gtx/integer.hpp"
#include "./gtx/intersect.hpp"
#include "./gtx/log_base.hpp"
#include "./gtx/matrix_cross_product.hpp"
#include "./gtx/matrix_interpolation.hpp"
#include "./gtx/matrix_major_storage.hpp"
#include "./gtx/matrix_operation.hpp"
#include "./gtx/matrix_query.hpp"
#include "./gtx/mixed_product.hpp"
#include "./gtx/multiple.hpp"
#include "./gtx/norm.hpp"
#include "./gtx/normal.hpp"
#include "./gtx/normalize_dot.hpp"
#include "./gtx/number_precision.hpp"
#include "./gtx/ocl_type.hpp"
#include "./gtx/optimum_pow.hpp"
#include "./gtx/orthonormalize.hpp"
#include "./gtx/perpendicular.hpp"
#include "./gtx/polar_coordinates.hpp"
#include "./gtx/projection.hpp"
#include "./gtx/quaternion.hpp"
#include "./gtx/raw_data.hpp"
#include "./gtx/rotate_vector.hpp"
#include "./gtx/spline.hpp"
#include "./gtx/std_based_type.hpp"
#include "./gtx/string_cast.hpp"
#include "./gtx/transform.hpp"
#include "./gtx/transform2.hpp"
#include "./gtx/vec1.hpp"
#include "./gtx/vector_access.hpp"
#include "./gtx/vector_angle.hpp"
#include "./gtx/vector_query.hpp"
#include "./gtx/verbose_operator.hpp"
#include "./gtx/wrap.hpp"
#if(GLM_ARCH & GLM_ARCH_SSE2)
# include "./gtx/simd_vec4.hpp"
# include "./gtx/simd_mat4.hpp"
#endif
#include "./virtrev/xstream.hpp"
//const float goldenRatio = 1.618033988749894848f;
//const float pi = 3.141592653589793238f;
#endif //glm_ext

129
Glm/glm.hpp

@ -0,0 +1,129 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref core
/// @file glm/glm.hpp
/// @date 2005-01-14 / 2011-10-24
/// @author Christophe Riccio
///
/// @defgroup core GLM Core
///
/// @brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
///
/// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and
/// C++ functions that mirror the GLSL functions. It also includes
/// @ref core_precision "a set of precision-based types" that can be used in the appropriate
/// functions. The C++ types are all based on a basic set of @ref core_template "template types".
///
/// The best documentation for GLM Core is the current GLSL specification,
/// <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.clean.pdf">version 4.2
/// (pdf file)</a>.
/// There are a few @ref pg_differences "differences" between GLM core and GLSL.
///
/// GLM core functionnalities require <glm/glm.hpp> to be included to be used.
///
/// @defgroup core_types Types
///
/// @brief The standard types defined by the specification.
///
/// These types are all typedefs of more generalized, template types. To see the definiton
/// of these template types, go to @ref core_template.
///
/// @ingroup core
///
/// @defgroup core_precision Precision types
///
/// @brief Non-GLSL types that are used to define precision-based types.
///
/// The GLSL language allows the user to define the precision of a particular variable.
/// In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
/// with OpenGL ES's precision qualifiers, where they @em do have an effect.
///
/// C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
/// a number of typedefs of the @ref core_template that use a particular precision.
///
/// None of these types make any guarantees about the actual precision used.
///
/// @ingroup core
///
/// @defgroup core_template Template types
///
/// @brief The generic template types used as the basis for the core types.
///
/// These types are all templates used to define the actual @ref core_types.
/// These templetes are implementation details of GLM types and should not be used explicitly.
///
/// @ingroup core
///////////////////////////////////////////////////////////////////////////////////
#include "core/_fixes.hpp"
#ifndef glm_glm
#define glm_glm
#include <cmath>
#include <climits>
#include <cfloat>
#include <limits>
#include <cstdio>
//#include <type_traits>
#include "core/setup.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
# define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
# pragma message("GLM: Core library included")
#endif//GLM_MESSAGE
#include "./core/_detail.hpp"
#include "./core/_vectorize.hpp"
#include "./core/type.hpp"
#include "./core/func_trigonometric.hpp"
#include "./core/func_exponential.hpp"
#include "./core/func_common.hpp"
#include "./core/func_packing.hpp"
#include "./core/func_geometric.hpp"
#include "./core/func_matrix.hpp"
#include "./core/func_vector_relational.hpp"
#include "./core/func_integer.hpp"
#include "./core/func_noise.hpp"
#include "./core/_swizzle.hpp"
////////////////////
// check type sizes
#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::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

186
Glm/gtc/constants.hpp

@ -0,0 +1,186 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_constants
/// @file glm/gtc/constants.hpp
/// @date 2011-09-30 / 2012-01-25
/// @author Christophe Riccio
///
/// @see core (dependence)
/// @see gtc_half_float (dependence)
///
/// @defgroup gtc_constants GLM_GTC_constants
/// @ingroup gtc
///
/// @brief Allow to perform bit operations on integer values
///
/// <glm/gtc/constants.hpp> need to be included to use these features.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTC_constants
#define GLM_GTC_constants GLM_VERSION
// Dependency:
#include "../glm.hpp"
#include "../gtc/half_float.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTC_constants extension included")
#endif
namespace glm
{
/// @addtogroup gtc_constants
/// @{
/// Return the epsilon constant for floating point types.
/// @todo Implement epsilon for half-precision floating point type.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType epsilon();
/// Return 0.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType zero();
/// Return 1.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType one();
/// Return the pi constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType pi();
/// Return square root of pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_pi();
/// Return pi / 2.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType half_pi();
/// Return pi / 4.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType quarter_pi();
/// Return 1 / pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType one_over_pi();
/// Return 2 / pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType two_over_pi();
/// Return 2 / sqrt(pi).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType two_over_root_pi();
/// Return 1 / sqrt(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType one_over_root_two();
/// Return sqrt(pi / 2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_half_pi();
/// Return sqrt(2 * pi).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_two_pi();
/// Return sqrt(ln(4)).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_ln_four();
/// Return e constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType e();
/// Return Euler's constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType euler();
/// Return sqrt(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_two();
/// Return sqrt(3).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_three();
/// Return sqrt(5).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType root_five();
/// Return ln(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType ln_two();
/// Return ln(10).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType ln_ten();
/// Return ln(ln(2)).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType ln_ln_two();
/// Return 1 / 3.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType third();
/// Return 2 / 3.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType two_thirds();
/// Return the golden ratio constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL genType golden_ratio();
/// @}
} //namespace glm
#include "constants.inl"
#endif//GLM_GTC_constants

186
Glm/gtc/constants.inl

@ -0,0 +1,186 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtx_constants
/// @file glm/gtx/constants.inl
/// @date 2011-10-14 / 2012-01-25
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER genType epsilon()
{
return std::numeric_limits<genType>::epsilon();
}
template <>
GLM_FUNC_QUALIFIER half epsilon()
{
return half(1.19209290e-007);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType zero()
{
return genType(0);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType one()
{
return genType(1);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType pi()
{
return genType(3.14159265358979323846264338327950288);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_pi()
{
return genType(1.772453850905516027);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType half_pi()
{
return genType(1.57079632679489661923132169163975144);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType quarter_pi()
{
return genType(0.785398163397448309615660845819875721);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType one_over_pi()
{
return genType(0.318309886183790671537767526745028724);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType two_over_pi()
{
return genType(0.636619772367581343075535053490057448);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType two_over_root_pi()
{
return genType(1.12837916709551257389615890312154517);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType one_over_root_two()
{
return genType(0.707106781186547524400844362104849039);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_half_pi()
{
return genType(1.253314137315500251);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_two_pi()
{
return genType(2.506628274631000502);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_ln_four()
{
return genType(1.17741002251547469);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType e()
{
return genType(2.71828182845904523536);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType euler()
{
return genType(0.577215664901532860606);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_two()
{
return genType(1.41421356237309504880168872420969808);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_three()
{
return genType(1.73205080756887729352744634150587236);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType root_five()
{
return genType(2.23606797749978969640917366873127623);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType ln_two()
{
return genType(0.693147180559945309417232121458176568);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType ln_ten()
{
return genType(2.30258509299404568401799145468436421);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType ln_ln_two()
{
return genType(-0.3665129205816643);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType third()
{
return genType(0.3333333333333333333333333333333333333333);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType two_thirds()
{
return genType(0.666666666666666666666666666666666666667);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType golden_ratio()
{
return genType(1.61803398874989484820458683436563811);
}
} //namespace glm

94
Glm/gtc/epsilon.hpp

@ -0,0 +1,94 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_epsilon
/// @file glm/gtc/epsilon.hpp
/// @date 2012-04-07 / 2012-04-07
/// @author Christophe Riccio
///
/// @see core (dependence)
/// @see gtc_half_float (dependence)
/// @see gtc_quaternion (dependence)
///
/// @defgroup gtc_epsilon GLM_GTC_epsilon
/// @ingroup gtc
///
/// @brief Comparison functions for a user defined epsilon values.
///
/// <glm/gtc/epsilon.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTC_epsilon
#define GLM_GTC_epsilon GLM_VERSION
// Dependency:
#include "../glm.hpp"
#include "../gtc/half_float.hpp"
#include "../gtc/quaternion.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTC_epsilon extension included")
#endif
namespace glm
{
/// @addtogroup gtc_epsilon
/// @{
/// Returns the component-wise compare of |x - y| < epsilon.
/// @see gtc_epsilon
template <typename genType>
typename genType::boolType epsilonEqual(
genType const & x,
genType const & y,
typename genType::value_type const & epsilon);
/// Returns the component-wise compare of |x - y| < epsilon.
/// @see gtc_epsilon
template <typename genType>
typename genType::boolType epsilonEqual(
genType const & x,
genType const & y,
genType const & epsilon);
/// Returns the component-wise compare of |x - y| < epsilon.
/// @see gtc_epsilon
template <typename genType>
typename genType::boolType epsilonNotEqual(
genType const & x,
genType const & y,
typename genType::value_type const & epsilon);
/// Returns the component-wise compare of |x - y| >= epsilon.
/// @see gtc_epsilon
template <typename genType>
typename genType::boolType epsilonNotEqual(
genType const & x,
genType const & y,
genType const & epsilon);
/// @}
}//namespace glm
#include "epsilon.inl"
#endif//GLM_GTC_epsilon

286
Glm/gtc/epsilon.inl

@ -0,0 +1,286 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_epsilon
/// @file glm/gtc/epsilon.inl
/// @date 2012-04-07 / 2012-04-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
GLM_FUNC_QUALIFIER bool epsilonEqual
(
glm::half const & x,
glm::half const & y,
glm::half const & epsilon
)
{
return abs(x - y) < epsilon;
}
GLM_FUNC_QUALIFIER bool epsilonEqual
(
float const & x,
float const & y,
float const & epsilon
)
{
return abs(x - y) < epsilon;
}
GLM_FUNC_QUALIFIER bool epsilonEqual
(
double const & x,
double const & y,
double const & epsilon
)
{
return abs(x - y) < epsilon;
}
GLM_FUNC_QUALIFIER bool epsilonNotEqual
(
glm::half const & x,
glm::half const & y,
glm::half const & epsilon
)
{
return abs(x - y) >= epsilon;
}
GLM_FUNC_QUALIFIER bool epsilonNotEqual
(
float const & x,
float const & y,
float const & epsilon
)
{
return abs(x - y) >= epsilon;
}
GLM_FUNC_QUALIFIER bool epsilonNotEqual
(
double const & x,
double const & y,
double const & epsilon
)
{
return abs(x - y) >= epsilon;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonEqual
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
valType const & epsilon)
{
return detail::tvec2<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonEqual
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & epsilon
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonEqual
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
valType const & epsilon)
{
return detail::tvec3<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon,
abs(x.z - y.z) < epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonEqual
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & epsilon
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y,
abs(x.z - y.z) < epsilon.z);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
valType const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon,
abs(x.z - y.z) < epsilon,
abs(x.w - y.w) < epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y,
abs(x.z - y.z) < epsilon.z,
abs(x.w - y.w) < epsilon.w);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonNotEqual
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
valType const & epsilon
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> epsilonNotEqual
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & epsilon
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonNotEqual
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
valType const & epsilon
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon,
abs(x.z - y.z) >= epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> epsilonNotEqual
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & epsilon
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y,
abs(x.z - y.z) >= epsilon.z);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
valType const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon,
abs(x.z - y.z) >= epsilon,
abs(x.w - y.w) >= epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y,
abs(x.z - y.z) >= epsilon.z,
abs(x.w - y.w) >= epsilon.w);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonEqual
(
detail::tquat<valType> const & x,
detail::tquat<valType> const & y,
valType const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon,
abs(x.z - y.z) < epsilon,
abs(x.w - y.w) < epsilon);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> epsilonNotEqual
(
detail::tquat<valType> const & x,
detail::tquat<valType> const & y,
valType const & epsilon
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon,
abs(x.z - y.z) >= epsilon,
abs(x.w - y.w) >= epsilon);
}
}//namespace glm

454
Glm/gtc/half_float.hpp

@ -0,0 +1,454 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_half_float
/// @file glm/gtc/half_float.hpp
/// @date 2009-04-29 / 2012-11-06
/// @author Christophe Riccio
///
/// @see core (dependence)
///
/// @defgroup gtc_half_float GLM_GTC_half_float
/// @ingroup gtc
///
/// Defines the half-precision floating-point type, along with various typedefs for vectors and matrices.
/// <glm/gtc/half_float.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTC_half_float
#define GLM_GTC_half_float GLM_VERSION
// Dependency:
#include "../glm.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTC_half_float extension included")
#endif
namespace glm{
namespace detail
{
#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
template <>
struct tvec2<half>
{
enum ctor{null};
typedef half value_type;
typedef std::size_t size_type;
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec2<half> type;
typedef tvec2<bool> bool_type;
//////////////////////////////////////
// Data
half x, y;
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL half & operator[](size_type i);
GLM_FUNC_DECL half const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec2();
GLM_FUNC_DECL tvec2(tvec2<half> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec2(ctor);
GLM_FUNC_DECL explicit tvec2(
half const & s);
GLM_FUNC_DECL explicit tvec2(
half const & s1,
half const & s2);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec2(tref2<half> const & r);
//////////////////////////////////////
// Convertion 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 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(U const & x, V const & y);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec2<half>& operator= (tvec2<half> const & v);
GLM_FUNC_DECL tvec2<half>& operator+=(half const & s);
GLM_FUNC_DECL tvec2<half>& operator+=(tvec2<half> const & v);
GLM_FUNC_DECL tvec2<half>& operator-=(half const & s);
GLM_FUNC_DECL tvec2<half>& operator-=(tvec2<half> const & v);
GLM_FUNC_DECL tvec2<half>& operator*=(half const & s);
GLM_FUNC_DECL tvec2<half>& operator*=(tvec2<half> const & v);
GLM_FUNC_DECL tvec2<half>& operator/=(half const & s);
GLM_FUNC_DECL tvec2<half>& operator/=(tvec2<half> const & v);
GLM_FUNC_DECL tvec2<half>& operator++();
GLM_FUNC_DECL tvec2<half>& operator--();
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL half swizzle(comp X) const;
GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<half> swizzle(comp X, comp Y);
};
template <>
struct tvec3<half>
{
enum ctor{null};
typedef half value_type;
typedef std::size_t size_type;
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec3<half> type;
typedef tvec3<bool> bool_type;
//////////////////////////////////////
// Data
half x, y, z;
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL half & operator[](size_type i);
GLM_FUNC_DECL half const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec3();
GLM_FUNC_DECL tvec3(tvec3<half> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec3(ctor);
GLM_FUNC_DECL explicit tvec3(
half const & s);
GLM_FUNC_DECL explicit tvec3(
half const & s1,
half const & s2,
half const & s3);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec3(tref3<half> const & r);
//////////////////////////////////////
// Convertion 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);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec3<half>& operator= (tvec3<half> const & v);
GLM_FUNC_DECL tvec3<half>& operator+=(half const & s);
GLM_FUNC_DECL tvec3<half>& operator+=(tvec3<half> const & v);
GLM_FUNC_DECL tvec3<half>& operator-=(half const & s);
GLM_FUNC_DECL tvec3<half>& operator-=(tvec3<half> const & v);
GLM_FUNC_DECL tvec3<half>& operator*=(half const & s);
GLM_FUNC_DECL tvec3<half>& operator*=(tvec3<half> const & v);
GLM_FUNC_DECL tvec3<half>& operator/=(half const & s);
GLM_FUNC_DECL tvec3<half>& operator/=(tvec3<half> const & v);
GLM_FUNC_DECL tvec3<half>& operator++();
GLM_FUNC_DECL tvec3<half>& operator--();
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL half swizzle(comp X) const;
GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref3<half> swizzle(comp X, comp Y, comp Z);
};
template <>
struct tvec4<half>
{
enum ctor{null};
typedef half value_type;
typedef std::size_t size_type;
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec4<half> type;
typedef tvec4<bool> bool_type;
//////////////////////////////////////
// Data
half x, y, z, w;
//////////////////////////////////////
// Accesses
GLM_FUNC_DECL half & operator[](size_type i);
GLM_FUNC_DECL half const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tvec4();
GLM_FUNC_DECL tvec4(tvec4<half> const & v);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec4(ctor);
GLM_FUNC_DECL explicit tvec4(
half const & s);
GLM_FUNC_DECL explicit tvec4(
half const & s0,
half const & s1,
half const & s2,
half const & s3);
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec4(tref4<half> const & r);
//////////////////////////////////////
// Convertion 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(A const & x, B const & y, C const & z, D const & w);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
GLM_FUNC_DECL tvec4<half>& operator= (tvec4<half> const & v);
GLM_FUNC_DECL tvec4<half>& operator+=(half const & s);
GLM_FUNC_DECL tvec4<half>& operator+=(tvec4<half> const & v);
GLM_FUNC_DECL tvec4<half>& operator-=(half const & s);
GLM_FUNC_DECL tvec4<half>& operator-=(tvec4<half> const & v);
GLM_FUNC_DECL tvec4<half>& operator*=(half const & s);
GLM_FUNC_DECL tvec4<half>& operator*=(tvec4<half> const & v);
GLM_FUNC_DECL tvec4<half>& operator/=(half const & s);
GLM_FUNC_DECL tvec4<half>& operator/=(tvec4<half> const & v);
GLM_FUNC_DECL tvec4<half>& operator++();
GLM_FUNC_DECL tvec4<half>& operator--();
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL half swizzle(comp X) const;
GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref4<half> swizzle(comp X, comp Y, comp Z, comp W);
};
#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
}
//namespace detail
/// @addtogroup gtc_half_float
/// @{
/// Type for half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::half half;
/// Vector of 2 half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tvec2<detail::half> hvec2;
/// Vector of 3 half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tvec3<detail::half> hvec3;
/// Vector of 4 half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tvec4<detail::half> hvec4;
/// 2 * 2 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat2x2<detail::half> hmat2;
/// 3 * 3 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat3x3<detail::half> hmat3;
/// 4 * 4 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat4x4<detail::half> hmat4;
/// 2 * 2 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat2x2<detail::half> hmat2x2;
/// 2 * 3 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat2x3<detail::half> hmat2x3;
/// 2 * 4 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat2x4<detail::half> hmat2x4;
/// 3 * 2 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat3x2<detail::half> hmat3x2;
/// 3 * 3 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat3x3<detail::half> hmat3x3;
/// 3 * 4 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat3x4<detail::half> hmat3x4;
/// 4 * 2 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat4x2<detail::half> hmat4x2;
/// 4 * 3 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat4x3<detail::half> hmat4x3;
/// 4 * 4 matrix of half-precision floating-point numbers.
/// @see gtc_half_float
typedef detail::tmat4x4<detail::half> hmat4x4;
/// Returns the absolute value of a half-precision floating-point value
/// @see gtc_half_float
GLM_FUNC_DECL half abs(half const & x);
/// Returns the absolute value of a half-precision floating-point two dimensional vector
/// @see gtc_half_float
GLM_FUNC_DECL hvec2 abs(hvec2 const & x);
/// Returns the absolute value of a half-precision floating-point three dimensional vector
/// @see gtc_half_float
GLM_FUNC_DECL hvec3 abs(hvec3 const & x);
/// Returns the absolute value of a half-precision floating-point four dimensional vector
/// @see gtc_half_float
GLM_FUNC_DECL hvec4 abs(hvec4 const & x);
/// Selects which vector each returned component comes
/// from. For a component of <a> that is false, the
/// corresponding component of x is returned. For a
/// component of a that is true, the corresponding
/// component of y is returned. Components of x and y that
/// are not selected are allowed to be invalid floating point
/// values and will have no effect on the results. Thus, this
/// provides different functionality than
/// genType mix(genType x, genType y, genType(a))
/// where a is a Boolean vector.
///
/// @see gtc_half_float
GLM_FUNC_DECL half mix(half const & x, half const & y, bool const & a);
/// @}
}// namespace glm
#include "half_float.inl"
#endif//GLM_GTC_half_float

Some files were not shown because too many files changed in this diff

Loading…
Cancel
Save