diff --git a/CMakeLists.txt b/CMakeLists.txt index 58d77043..7da4d804 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,48 +11,33 @@ if(NOT GLM_TEST_ENABLE) message(FATAL_ERROR "GLM is a header only library, no need to build it. Set the option GLM_TEST_ENABLE with ON to build and run the test bench") endif() -option(GLM_USE_INTEL "Use Intel Compiler" OFF) +if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND UNIX)) + option(GLM_TEST_ENABLE_CXX_98 "Enable C++ 98" OFF) + option(GLM_TEST_ENABLE_CXX_0X "Enable C++ 0x" OFF) + option(GLM_TEST_ENABLE_CXX_11 "Enable C++ 11" OFF) + option(GLM_TEST_ENABLE_CXX_1Y "Enable C++ 1y" OFF) + option(GLM_TEST_ENABLE_CXX_PEDANTIC "Pedantic" ON) -option(GLM_TEST_ENABLE_CXX_11 "Enable C++ 11" OFF) -if(GLM_TEST_ENABLE_CXX_11) - if(GLM_USE_INTEL) - add_definitions(/Qstd=c++0x) + if(GLM_TEST_ENABLE_CXX_PEDANTIC) + add_definitions(-pedantic) endif() - if(CMAKE_COMPILER_IS_GNUCXX) + if(GLM_TEST_ENABLE_CXX_1Y) + add_definitions(-std=c++1y) + elseif(GLM_TEST_ENABLE_CXX_11) + add_definitions(-std=c++11) + elseif(GLM_TEST_ENABLE_CXX_0X) add_definitions(-std=c++0x) - endif() -elseif(NOT GLM_TEST_ENABLE_CXX_11) - if(CMAKE_COMPILER_IS_GNUCXX) + elseif(GLM_TEST_ENABLE_CXX_98) add_definitions(-std=c++98) endif() endif() -option(GLM_TEST_ENABLE_LANG_EXTENSIONS "Enable language extensions" OFF) -if(GLM_TEST_ENABLE_LANG_EXTENSIONS) - if(GLM_USE_INTEL) - add_definitions(/Qintel-extensions) - add_definitions(-intel-extensions) - endif() +if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND WIN32)) + option(GLM_TEST_ENABLE_MS_EXTENSIONS "Enable MS extensions" OFF) - if(CMAKE_COMPILER_IS_GNUCXX) - #Doesn't seem to work... - #add_definitions(-fms-extensions) - #add_definitions(-D_MSC_EXTENSIONS) - endif() - -elseif(NOT GLM_TEST_ENABLE_LANG_EXTENSIONS) - if(GLM_USE_INTEL) - add_definitions(/Qintel-extensions-) - add_definitions(-no-intel-extensions) - endif() - - if(CMAKE_COMPILER_IS_GNUCXX) - add_definitions(-pedantic) - endif() - - if(MSVC) - add_definitions(/Za) + if(NOT GLM_TEST_ENABLE_MS_EXTENSIONS) + add_definitions(/Za) endif() endif() diff --git a/glm/core/_swizzle.hpp b/glm/core/_swizzle.hpp index bf1d20dc..33815ff8 100644 --- a/glm/core/_swizzle.hpp +++ b/glm/core/_swizzle.hpp @@ -60,8 +60,8 @@ namespace detail typedef T value_type; protected: - value_type& elem (size_t i) { return (reinterpret_cast(_buffer))[i]; } - const value_type& elem (size_t i) const { return (reinterpret_cast(_buffer))[i]; } + GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast(_buffer))[i]; } + GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast(_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 @@ -77,19 +77,19 @@ namespace detail template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1)); } + GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); } }; template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); } + GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); } }; template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } + 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 @@ -110,67 +110,73 @@ namespace detail typedef VecType vec_type; typedef ValueType value_type; - _swizzle_base2& operator= (const ValueType& t) + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t) { for (int i = 0; i < N; ++i) (*this)[i] = t; return *this; } - _swizzle_base2& operator= (const VecType& that) + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e = t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } }; _apply_op(that, op()); return *this; } - void operator -= (const VecType& that) + GLM_FUNC_QUALIFIER void operator -= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e -= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } }; _apply_op(that, op()); } - void operator += (const VecType& that) + GLM_FUNC_QUALIFIER void operator += (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e += t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } }; _apply_op(that, op()); } - void operator *= (const VecType& that) + GLM_FUNC_QUALIFIER void operator *= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e *= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } }; _apply_op(that, op()); } - void operator /= (const VecType& that) + GLM_FUNC_QUALIFIER void operator /= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e /= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } }; _apply_op(that, op()); } - value_type& operator[] (size_t i) + GLM_FUNC_QUALIFIER value_type& operator[] (size_t i) { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } - value_type operator[] (size_t i) const + GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } protected: template - void _apply_op(const VecType& that, T op) + 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 @@ -191,11 +197,14 @@ namespace detail typedef ValueType value_type; struct Stub {}; - _swizzle_base2& operator= (Stub const &) { return *this; } + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; } - value_type operator[] (size_t i) const + GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } }; @@ -207,7 +216,7 @@ namespace detail using base_type::operator=; - operator VecType () const { return (*this)(); } + GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); } }; // @@ -223,17 +232,17 @@ namespace detail // #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE2 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ { \ return a() OPERAND b(); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } @@ -243,12 +252,12 @@ namespace detail // #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } @@ -258,7 +267,7 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \ { \ return FUNCTION(a()); \ } @@ -268,22 +277,22 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a, b()); \ } @@ -293,22 +302,22 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\ + 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 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ + 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); \ } diff --git a/glm/core/setup.hpp b/glm/core/setup.hpp index dcb43b40..3502a7d0 100644 --- a/glm/core/setup.hpp +++ b/glm/core/setup.hpp @@ -52,6 +52,7 @@ #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 @@ -59,6 +60,8 @@ # 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__) @@ -76,20 +79,24 @@ // Report platform detection #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED)) # define GLM_MESSAGE_PLATFORM_DISPLAYED -# if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS) -# pragma message("GLM: Windows platform detected") +# 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_ANDROID) -# pragma message("GLM: Android platform detected") -# elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL) -# pragma message("GLM: Chrone Native Client detected") # elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN) # pragma message("GLM: platform unknown") # else @@ -105,6 +112,17 @@ #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 @@ -117,6 +135,7 @@ #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 @@ -137,8 +156,6 @@ #define GLM_COMPILER_GCC46 0x020000D0 #define GLM_COMPILER_GCC47 0x020000E0 #define GLM_COMPILER_GCC48 0x020000F0 -#define GLM_COMPILER_GCC49 0x02000100 -#define GLM_COMPILER_GCC50 0x02000200 // G++ command line to display defined // echo "" | g++ -E -dM -x c++ - | sort @@ -181,17 +198,6 @@ // LLVM GCC #define GLM_COMPILER_LLVM_GCC 0x40000000 -// Intel -#define GLM_COMPILER_INTEL 0x80000000 -#define GLM_COMPILER_INTEL9 0x80000010 -#define GLM_COMPILER_INTEL10_0 0x80000020 -#define GLM_COMPILER_INTEL10_1 0x80000030 -#define GLM_COMPILER_INTEL11_0 0x80000040 -#define GLM_COMPILER_INTEL11_1 0x80000050 -#define GLM_COMPILER_INTEL12_0 0x80000060 -#define GLM_COMPILER_INTEL12_1 0x80000070 -#define GLM_COMPILER_INTEL13_0 0x80000080 - // Build model #define GLM_MODEL_32 0x00000010 #define GLM_MODEL_64 0x00000020 @@ -215,7 +221,7 @@ # define GLM_COMPILER GLM_COMPILER_INTEL12_0 # elif __INTEL_COMPILER == 1210 # define GLM_COMPILER GLM_COMPILER_INTEL12_1 -# elif __INTEL_COMPILER == 1300 +# elif __INTEL_COMPILER >= 1300 # define GLM_COMPILER GLM_COMPILER_INTEL13_0 # else # define GLM_COMPILER GLM_COMPILER_INTEL @@ -223,41 +229,16 @@ // CUDA #elif defined(__CUDACC__) -# define GLM_COMPILER GLM_COMPILER_CUDA -/* # if CUDA_VERSION < 3000 # error "GLM requires CUDA 3.0 or higher" -# elif CUDA_VERSION == 3000 -# define GLM_COMPILER GLM_COMPILER_CUDA30 -# elif CUDA_VERSION == 3010 -# define GLM_COMPILER GLM_COMPILER_CUDA31 -# elif CUDA_VERSION == 3020 -# define GLM_COMPILER GLM_COMPILER_CUDA32 -# elif CUDA_VERSION == 4000 -# define GLM_COMPILER GLM_COMPILER_CUDA40 -# elif CUDA_VERSION == 4010 -# define GLM_COMPILER GLM_COMPILER_CUDA41 -# elif CUDA_VERSION == 4020 -# define GLM_COMPILER GLM_COMPILER_CUDA42 # else # define GLM_COMPILER GLM_COMPILER_CUDA # endif -*/ // Visual C++ #elif defined(_MSC_VER) -# if _MSC_VER == 900 -# define GLM_COMPILER GLM_COMPILER_VC2 -# elif _MSC_VER == 1000 -# define GLM_COMPILER GLM_COMPILER_VC4 -# elif _MSC_VER == 1100 -# define GLM_COMPILER GLM_COMPILER_VC5 -# elif _MSC_VER == 1200 -# define GLM_COMPILER GLM_COMPILER_VC6 -# elif _MSC_VER == 1300 -# define GLM_COMPILER GLM_COMPILER_VC2002 -# elif _MSC_VER == 1310 -# define GLM_COMPILER GLM_COMPILER_VC2003 +# 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 @@ -266,13 +247,17 @@ # 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__ == 2) && (__clang_minor__ == 6) +# 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 @@ -294,7 +279,9 @@ # 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) +# 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 @@ -328,27 +315,17 @@ # define GLM_COMPILER (GLM_COMPILER_GCC47) # elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) # define GLM_COMPILER (GLM_COMPILER_GCC48) -# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 9) +# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) +# define GLM_COMPILER (GLM_COMPILER_GCC49) +# elif (__GNUC__ > 4 ) # define GLM_COMPILER (GLM_COMPILER_GCC49) -# elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 0) -# define GLM_COMPILER (GLM_COMPILER_GCC50) # else # define GLM_COMPILER (GLM_COMPILER_GCC) # endif // Borland C++ #elif defined(_BORLANDC_) -# if defined(VER125) -# define GLM_COMPILER GLM_COMPILER_BCB4 -# elif defined(VER130) -# define GLM_COMPILER GLM_COMPILER_BCB5 -# elif defined(VER140) -# define GLM_COMPILER GLM_COMPILER_BCB6 -# elif defined(VER200) -# define GLM_COMPILER GLM_COMPILER_BCB2009 -# else -# define GLM_COMPILER GLM_COMPILER_BC -# endif +# define GLM_COMPILER GLM_COMPILER_BC // Codewarrior #elif defined(__MWERKS__) @@ -446,7 +423,19 @@ #else # if(__cplusplus >= 201103L) # define GLM_LANG GLM_LANG_CXX11 -// -std=c++0x or -std=gnu++0x +# 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 @@ -455,17 +444,13 @@ # endif # elif(GLM_COMPILER & GLM_COMPILER_VC) # if(defined(_MSC_EXTENSIONS)) -# if(GLM_COMPILER >= GLM_COMPILER_VC2012) -# define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG) -# elif(GLM_COMPILER >= GLM_COMPILER_VC2010) +# if(GLM_COMPILER >= GLM_COMPILER_VC2010) # define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG) # else # define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG) # endif # else -# if(GLM_COMPILER >= GLM_COMPILER_VC2012) -# define GLM_LANG GLM_LANG_CXX11 -# elif(GLM_COMPILER >= GLM_COMPILER_VC2010) +# if(GLM_COMPILER >= GLM_COMPILER_VC2010) # define GLM_LANG GLM_LANG_CXX0X # else # define GLM_LANG GLM_LANG_CXX98 @@ -536,7 +521,9 @@ #elif(defined(GLM_FORCE_SSE2)) # define GLM_ARCH (GLM_ARCH_SSE2) #elif((GLM_COMPILER & GLM_COMPILER_VC) && (defined(_M_IX86) || defined(_M_X64))) -# if(defined(_M_CEE_PURE)) +# 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)) diff --git a/glm/core/type_int.hpp b/glm/core/type_int.hpp index 99b7ad95..670ed442 100644 --- a/glm/core/type_int.hpp +++ b/glm/core/type_int.hpp @@ -32,8 +32,7 @@ #include "setup.hpp" #if(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))) -//#if((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))) -#include +# include #endif namespace glm{ @@ -78,13 +77,13 @@ namespace detail typedef uint64 uint64; #endif// - typedef signed short lowp_int_t; + typedef signed int lowp_int_t; typedef signed int mediump_int_t; - typedef int64 highp_int_t; + typedef signed int highp_int_t; - typedef unsigned short lowp_uint_t; + typedef unsigned int lowp_uint_t; typedef unsigned int mediump_uint_t; - typedef uint64 highp_uint_t; + typedef unsigned int highp_uint_t; }//namespace detail typedef detail::int8 int8; @@ -217,7 +216,11 @@ namespace detail GLM_DETAIL_IS_INT(signed short); GLM_DETAIL_IS_INT(signed int); GLM_DETAIL_IS_INT(signed long); - GLM_DETAIL_IS_INT(highp_int_t); +# if(GLM_LANG >= GLM_LANG_CXX0X) + GLM_DETAIL_IS_INT(signed long long); +# else + GLM_DETAIL_IS_INT(glm::int64); +# endif ////////////////// // uint @@ -247,7 +250,11 @@ namespace detail GLM_DETAIL_IS_UINT(unsigned short); GLM_DETAIL_IS_UINT(unsigned int); GLM_DETAIL_IS_UINT(unsigned long); - GLM_DETAIL_IS_UINT(highp_uint_t); +# if(GLM_LANG >= GLM_LANG_CXX0X) + GLM_DETAIL_IS_INT(unsigned long long); +# else + GLM_DETAIL_IS_INT(glm::uint64); +# endif ////////////////// // bool diff --git a/glm/core/type_vec2.hpp b/glm/core/type_vec2.hpp index 1ae0d9cb..0c6e604f 100644 --- a/glm/core/type_vec2.hpp +++ b/glm/core/type_vec2.hpp @@ -54,21 +54,21 @@ namespace detail # if(GLM_COMPONENT == GLM_COMPONENT_CXXMS) union { -# if(defined(GLM_SWIZZLE)) - _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y) - _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g) - _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t) - _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, x, y) - _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, r, g) - _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, s, t) - _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y) - _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g) - _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t) -# endif//(defined(GLM_SWIZZLE)) + struct{value_type x, y;}; + struct{value_type r, g;}; + struct{value_type s, t;}; - struct {value_type r, g;}; - struct {value_type s, t;}; - struct {value_type x, y;}; +# if(defined(GLM_SWIZZLE)) + _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y) + _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g) + _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t) + _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, x, y) + _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, r, g) + _GLM_SWIZZLE2_3_MEMBERS(T, P, tvec3, s, t) + _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y) + _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g) + _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t) +# endif//(defined(GLM_SWIZZLE)) }; # elif(GLM_COMPONENT == GLM_COMPONENT_CXX98) union {value_type x, r, s;}; diff --git a/glm/core/type_vec3.hpp b/glm/core/type_vec3.hpp index 44175246..fad362d1 100644 --- a/glm/core/type_vec3.hpp +++ b/glm/core/type_vec3.hpp @@ -54,21 +54,21 @@ namespace detail # if(GLM_COMPONENT == GLM_COMPONENT_CXXMS) union { -# if(defined(GLM_SWIZZLE)) - _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z) - _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b) - _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p) - _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, x, y, z) - _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, r, g, b) - _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, s, t, p) - _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z) - _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b) - _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p) -# endif//(defined(GLM_SWIZZLE)) + struct{value_type x, y, z;}; + struct{value_type r, g, b;}; + struct{value_type s, t, p;}; - struct {value_type r, g, b;}; - struct {value_type s, t, p;}; - struct {value_type x, y, z;}; +# if(defined(GLM_SWIZZLE)) + _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z) + _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b) + _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p) + _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, x, y, z) + _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, r, g, b) + _GLM_SWIZZLE3_3_MEMBERS(T, P, tvec3, s, t, p) + _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z) + _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b) + _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p) +# endif//(defined(GLM_SWIZZLE)) }; # elif(GLM_COMPONENT == GLM_COMPONENT_CXX98) union {value_type x, r, s;}; diff --git a/glm/core/type_vec4.hpp b/glm/core/type_vec4.hpp index 9deca8a4..c3197fee 100644 --- a/glm/core/type_vec4.hpp +++ b/glm/core/type_vec4.hpp @@ -54,6 +54,10 @@ namespace detail # if(GLM_COMPONENT == GLM_COMPONENT_CXXMS) union { + struct {value_type r, g, b, a;}; + struct {value_type s, t, p, q;}; + struct {value_type x, y, z, w;}; + # if(defined(GLM_SWIZZLE)) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a) @@ -65,10 +69,6 @@ namespace detail _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q) # endif//(defined(GLM_SWIZZLE)) - - struct {value_type r, g, b, a;}; - struct {value_type s, t, p, q;}; - struct {value_type x, y, z, w;}; }; # elif(GLM_COMPONENT == GLM_COMPONENT_CXX98) union {value_type x, r, s;}; diff --git a/glm/gtc/type_ptr.inl b/glm/gtc/type_ptr.inl index ac14036a..6b3e1ac0 100644 --- a/glm/gtc/type_ptr.inl +++ b/glm/gtc/type_ptr.inl @@ -31,7 +31,7 @@ namespace glm /// @addtogroup gtc_type_ptr /// @{ - /// Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -42,7 +42,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the vector input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -53,7 +53,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -64,7 +64,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the vector input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -75,7 +75,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -86,7 +86,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the vector input. //! From GLM_GTC_type_ptr extension. template GLM_FUNC_QUALIFIER T * value_ptr @@ -97,7 +97,7 @@ namespace glm return &(vec.x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -108,7 +108,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -119,7 +119,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -130,7 +130,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -141,7 +141,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -152,7 +152,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. //! From GLM_GTC_type_ptr extension. template GLM_FUNC_QUALIFIER T * value_ptr @@ -163,7 +163,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -174,7 +174,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -185,7 +185,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -196,7 +196,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -207,7 +207,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -218,7 +218,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -229,7 +229,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -240,7 +240,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -251,7 +251,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -262,7 +262,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + //! Return the address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T * value_ptr @@ -273,7 +273,7 @@ namespace glm return &(mat[0].x); } - //! Return the constant address to the data of the input parameter. + /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr template GLM_FUNC_QUALIFIER T const * value_ptr @@ -284,6 +284,25 @@ namespace glm return &(mat[0].x); } + //! Return the address to the data of the matrix input. + /// @see gtc_type_ptr + template + GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3 & mat) + { + return &(mat[0].x); + } + + /// Return the constant address to the data of the quaternion input. + /// @see gtc_type_ptr + template + GLM_FUNC_QUALIFIER T * value_ptr + ( + detail::tquat & q + ) + { + return &(q[0]); + } + //! Return the constant address to the data of the input parameter. /// @see gtc_type_ptr template @@ -294,13 +313,16 @@ namespace glm { return &(q[0]); } - - //! Get the address of the matrix content. + + //! Return the address to the data of the quaternion input. /// @see gtc_type_ptr - template - GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3 & mat) + template + GLM_FUNC_QUALIFIER T * value_ptr + ( + detail::tquat & q + ) { - return &(mat[0].x); + return &(q[0]); } //! Build a vector from a pointer. diff --git a/readme.txt b/readme.txt index 3ecc52f1..74bcd8e5 100644 --- a/readme.txt +++ b/readme.txt @@ -53,10 +53,28 @@ GLM 0.9.5.0: 2013-XX-XX - Fixed perspective with zNear == 0 (#71) ================================================================================ -GLM 0.9.4.5: 2013-06-XX +GLM 0.9.4.6: 2013-08-XX -------------------------------------------------------------------------------- -- Fixed inclusion of intrinsics in "pure" mode #92 +- Fixed detection to select the last known compiler if newer version #106 +- Fixed is_int and is_uint code duplication with GCC and C++11 #107 +- Fixed test suite build while using Clang in C++11 mode +- Added c++1y mode support in CMake test suite +- Removed ms extension mode to CMake when no using Visual C++ +- Added pedantic mode to CMake test suite for Clang and GCC +- Added use of GCC frontend on Unix for ICC and Visual C++ fronted on Windows + for ICC +- Added compilation errors for unsupported compiler versions + +================================================================================ +GLM 0.9.4.5: 2013-08-12 +-------------------------------------------------------------------------------- +- Fixed CUDA support +- Fixed inclusion of intrinsics in "pure" mode #92 - Fixed language detection on GCC when the C++0x mode isn't enabled #95 +- Fixed issue #97: register is deprecated in C++11 +- Fixed issue #96: CUDA issues +- Added Windows CE detection #92 +- Added missing value_ptr for quaternions #99 ================================================================================ GLM 0.9.4.4: 2013-05-29 diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp index 068270f7..0bcc560a 100644 --- a/test/core/core_func_integer.cpp +++ b/test/core/core_func_integer.cpp @@ -170,15 +170,7 @@ namespace findMSB {0x08000000, 27}, {0x10000000, 28}, {0x20000000, 29}, - {0x40000000, 30}, - {0x80000000, 30}, - {0xffffffff, -1}, - {0xfffffffe, 0}, - {0xfffffffd, 1}, - {0xfffffffc, 1}, - {0xfffffffb, 2}, - {0xfffffffa, 2}, - {0xfffffff0, 3} + {0x40000000, 30} }; int test() @@ -209,8 +201,7 @@ namespace findLSB { {0x00000001, 0}, {0x00000003, 0}, - {0x00000002, 1}, - {0x80000000, 31} + {0x00000002, 1} }; int test() diff --git a/test/external/gli/core/operation.inl b/test/external/gli/core/operation.inl index 87999a81..58b6428f 100644 --- a/test/external/gli/core/operation.inl +++ b/test/external/gli/core/operation.inl @@ -123,8 +123,8 @@ namespace gli glm::byte * DstData = DstMipmap.data(); glm::byte const * const SrcData = SrcMipmap.data(); - std::size_t SizeX = std::min(std::size_t(SrcSize.x + SrcPosition.x), std::size_t(DstMipmap.dimensions().x + DstPosition.x)); - std::size_t SizeY = std::min(std::size_t(SrcSize.y + SrcPosition.y), std::size_t(DstMipmap.dimensions().y + DstPosition.y)); + std::size_t SizeX = glm::min(std::size_t(SrcSize.x + SrcPosition.x), std::size_t(DstMipmap.dimensions().x + DstPosition.x)); + std::size_t SizeY = glm::min(std::size_t(SrcSize.y + SrcPosition.y), std::size_t(DstMipmap.dimensions().y + DstPosition.y)); for(std::size_t j = 0; j < SizeY; ++j) { diff --git a/test/gtx/gtx_bit.cpp b/test/gtx/gtx_bit.cpp index a6bcffd1..9e826e21 100644 --- a/test/gtx/gtx_bit.cpp +++ b/test/gtx/gtx_bit.cpp @@ -361,8 +361,8 @@ namespace bitfieldInterleave int test() { - glm::uint32 x_max = 1 << 13; - glm::uint32 y_max = 1 << 12; + glm::uint32 x_max = 1 << 11; + glm::uint32 y_max = 1 << 10; // ALU std::vector Data(x_max * y_max); @@ -493,17 +493,14 @@ namespace bitfieldInterleave # if(GLM_ARCH != GLM_ARCH_PURE) { // SIMD - glm::int32 simd_x_max = 1 << 13; - glm::int32 simd_y_max = 1 << 12; - std::vector<__m128i> SimdData(x_max * y_max); std::vector<__m128i> SimdParam(x_max * y_max); for(int i = 0; i < SimdParam.size(); ++i) - SimdParam[i] = _mm_set_epi32(i % simd_x_max, 0, i / simd_y_max, 0); + SimdParam[i] = _mm_set_epi32(i % x_max, 0, i / y_max, 0); std::clock_t LastTime = std::clock(); - for(std::size_t i = 0; i < Data.size(); ++i) + for(std::size_t i = 0; i < SimdData.size(); ++i) SimdData[i] = glm::detail::_mm_bit_interleave_si128(SimdParam[i]); std::clock_t Time = std::clock() - LastTime;