Reorganized SIMD code

glm/detail/_features.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_features.hpp
-/// @date 2013-02-20 / 2013-02-20
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/_fixes.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_fixes.hpp
-/// @date 2011-02-21 / 2011-11-22
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include <cmath>
 

glm/detail/_noise.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_noise.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/_swizzle.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_swizzle.hpp
-/// @date 2006-04-20 / 2011-02-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/_swizzle_func.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_swizzle_func.hpp
-/// @date 2011-10-16 / 2011-10-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/_vectorize.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/_vectorize.hpp
-/// @date 2011-10-14 / 2011-10-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/dummy.cpp

@@ -1,37 +1,10 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/glm.hpp>

glm/detail/func_common.hpp

@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/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>
 ///
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/func_common.inl

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/func_common.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_vector_relational.hpp"
 #include "type_vec2.hpp"

glm/detail/func_common_simd.inl

@@ -33,6 +33,110 @@ namespace detail
 	static const __m128 GLM_VAR_USED _ps_2pow23 = _mm_set_ps1(8388608.0f);
 	static const __m128 GLM_VAR_USED _ps_1 = _mm_set_ps1(1.0f);
 
+/*
+	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 abs_ps(__m128 x)
 	{
 		return _mm_and_ps(abs4Mask, x);

glm/detail/func_exponential.hpp

@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/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>
 ///
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/func_exponential.inl

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"

glm/detail/func_geometric.hpp

@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/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>
 /// 
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These operate on vectors as vectors, not component-wise.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/func_geometric.inl

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/func_geometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include "func_exponential.hpp"
 #include "func_common.hpp"

glm/detail/func_integer.hpp

@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/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>
 /// 
@@ -37,7 +9,6 @@
 /// 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.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/func_integer.inl

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/func_integer.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
@@ -387,3 +358,8 @@ namespace detail
 		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
 	}
 }//namespace glm
+
+#if GLM_ARCH != GLM_FORCE_PURE && GLM_HAS_ANONYMOUS_UNION && GLM_NOT_BUGGY_VC32BITS
+#	include "func_integer_simd.inl"
+#endif
+

glm/detail/intrinsic_integer.inl → glm/detail/func_integer_simd.inl

@@ -1,30 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2012 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/detail/intrinsic_integer.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
+/// @file glm/detail/func_integer_simd.inl
 
 namespace glm{
 namespace detail
@@ -136,4 +111,4 @@ namespace detail
 		return Reg1;
 	}
 }//namespace detail
-}//namespace glms
+}//namespace glm

glm/detail/func_matrix.inl

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/func_matrix.inl
-/// @date 2008-03-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #include "../geometric.hpp"
 #include <limits>

glm/detail/func_matrix_simd.inl

@@ -1,8 +1,1050 @@
+/// @ref core
+/// @file glm/detail/func_matrix_simd.inl
+
 #include "type_mat4x4.hpp"
 #include "func_geometric.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
+	static const __m128 GLM_VAR_USED _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
+	static const __m128 GLM_VAR_USED _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
+
+	template <typename matType>
+	GLM_FUNC_QUALIFIER matType sse_comp_mul_ps
+	(
+		__m128 const in1[4],
+		__m128 const in2[4],
+		__m128 out[4]
+	)
+	{
+		out[0] = _mm_mul_ps(in1[0], in2[0]);
+		out[1] = _mm_mul_ps(in1[1], in2[1]);
+		out[2] = _mm_mul_ps(in1[2], in2[2]);
+		out[3] = _mm_mul_ps(in1[3], in2[3]);
+	}
+
+	GLM_FUNC_QUALIFIER void sse_add_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
+	{
+		{
+			out[0] = _mm_add_ps(in1[0], in2[0]);
+			out[1] = _mm_add_ps(in1[1], in2[1]);
+			out[2] = _mm_add_ps(in1[2], in2[2]);
+			out[3] = _mm_add_ps(in1[3], in2[3]);
+		}
+	}
+
+	GLM_FUNC_QUALIFIER void sse_sub_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
+	{
+		{
+			out[0] = _mm_sub_ps(in1[0], in2[0]);
+			out[1] = _mm_sub_ps(in1[1], in2[1]);
+			out[2] = _mm_sub_ps(in1[2], in2[2]);
+			out[3] = _mm_sub_ps(in1[3], in2[3]);
+		}
+	}
+
+	GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 const m[4], __m128 v)
+	{
+		__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(m[0], v0);
+		__m128 m1 = _mm_mul_ps(m[1], v1);
+		__m128 m2 = _mm_mul_ps(m[2], v2);
+		__m128 m3 = _mm_mul_ps(m[3], v3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		return a2;
+	}
+
+	GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 v, __m128 const m[4])
+	{
+		__m128 i0 = m[0];
+		__m128 i1 = m[1];
+		__m128 i2 = m[2];
+		__m128 i3 = m[3];
+
+		__m128 m0 = _mm_mul_ps(v, i0);
+		__m128 m1 = _mm_mul_ps(v, i1);
+		__m128 m2 = _mm_mul_ps(v, i2);
+		__m128 m3 = _mm_mul_ps(v, i3);
+
+		__m128 u0 = _mm_unpacklo_ps(m0, m1);
+		__m128 u1 = _mm_unpackhi_ps(m0, m1);
+		__m128 a0 = _mm_add_ps(u0, u1);
+
+		__m128 u2 = _mm_unpacklo_ps(m2, m3);
+		__m128 u3 = _mm_unpackhi_ps(m2, m3);
+		__m128 a1 = _mm_add_ps(u2, u3);
+
+		__m128 f0 = _mm_movelh_ps(a0, a1);
+		__m128 f1 = _mm_movehl_ps(a1, a0);
+		__m128 f2 = _mm_add_ps(f0, f1);
+
+		return f2;
+	}
+
+	GLM_FUNC_QUALIFIER void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
+	{
+		{
+			__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 m0 = _mm_mul_ps(in1[0], e0);
+			__m128 m1 = _mm_mul_ps(in1[1], e1);
+			__m128 m2 = _mm_mul_ps(in1[2], e2);
+			__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+			__m128 a0 = _mm_add_ps(m0, m1);
+			__m128 a1 = _mm_add_ps(m2, m3);
+			__m128 a2 = _mm_add_ps(a0, a1);
+
+			out[0] = a2;
+		}
+
+		{
+			__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 m0 = _mm_mul_ps(in1[0], e0);
+			__m128 m1 = _mm_mul_ps(in1[1], e1);
+			__m128 m2 = _mm_mul_ps(in1[2], e2);
+			__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+			__m128 a0 = _mm_add_ps(m0, m1);
+			__m128 a1 = _mm_add_ps(m2, m3);
+			__m128 a2 = _mm_add_ps(a0, a1);
+
+			out[1] = a2;
+		}
+
+		{
+			__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 m0 = _mm_mul_ps(in1[0], e0);
+			__m128 m1 = _mm_mul_ps(in1[1], e1);
+			__m128 m2 = _mm_mul_ps(in1[2], e2);
+			__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+			__m128 a0 = _mm_add_ps(m0, m1);
+			__m128 a1 = _mm_add_ps(m2, m3);
+			__m128 a2 = _mm_add_ps(a0, a1);
+
+			out[2] = a2;
+		}
+
+		{
+			//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
+			__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 m0 = _mm_mul_ps(in1[0], e0);
+			__m128 m1 = _mm_mul_ps(in1[1], e1);
+			__m128 m2 = _mm_mul_ps(in1[2], e2);
+			__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+			__m128 a0 = _mm_add_ps(m0, m1);
+			__m128 a1 = _mm_add_ps(m2, m3);
+			__m128 a2 = _mm_add_ps(a0, a1);
+
+			out[3] = a2;
+		}
+	}
+
+	GLM_FUNC_QUALIFIER void sse_transpose_ps(__m128 const in[4], __m128 out[4])
+	{
+		__m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
+		__m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
+		__m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
+		__m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
+
+		out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
+		out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
+		out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
+		out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
+	}
+
+	GLM_FUNC_QUALIFIER __m128 sse_slow_det_ps(__m128 const in[4])
+	{
+		__m128 Fac0;
+		{
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac0 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac1;
+		{
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac1 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+
+		__m128 Fac2;
+		{
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac2 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac3;
+		{
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac3 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac4;
+		{
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac4 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac5;
+		{
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac5 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+		__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+		// m[1][0]
+		// m[0][0]
+		// m[0][0]
+		// m[0][0]
+		__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][1]
+		// m[0][1]
+		// m[0][1]
+		// m[0][1]
+		__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][2]
+		// m[0][2]
+		// m[0][2]
+		// m[0][2]
+		__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][3]
+		// m[0][3]
+		// m[0][3]
+		// m[0][3]
+		__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// col0
+		// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+		// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+		// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+		// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+		__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+		__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+		__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+		__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+		__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+		__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+		// col1
+		// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+		// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+		// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+		// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+		__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+		__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+		__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+		__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+		__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+		__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+		// col2
+		// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+		// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+		// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+		// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+		__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+		__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+		__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+		__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+		__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+		__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+		// col3
+		// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+		// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+		// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+		// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+		__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+		__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+		__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+		__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+		__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+		__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+		__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+		//	valType Determinant = m[0][0] * Inverse[0][0]
+		//						+ m[0][1] * Inverse[1][0]
+		//						+ m[0][2] * Inverse[2][0]
+		//						+ m[0][3] * Inverse[3][0];
+		__m128 Det0 = sse_dot_ps(in[0], Row2);
+		return Det0;
+	}
+
+	GLM_FUNC_QUALIFIER __m128 sse_detd_ps
+	(
+		__m128 const m[4]
+	)
+	{
+		// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
+
+		//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];
+
+		// First 2 columns
+ 		__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
+ 		__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
+		__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+		// Second 2 columns
+		__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
+		__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
+		__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+		// Columns subtraction
+		__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+		// Last 2 rows
+		__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
+		__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
+		__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+		__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+		//tvec4<T, P> 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));
+
+		__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
+		__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
+		__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+		__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+		__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
+		__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
+		__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+		__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+		__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+		__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
+		__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
+		__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+		__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+		__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+		//return m[0][0] * DetCof[0]
+		//	 + m[0][1] * DetCof[1]
+		//	 + m[0][2] * DetCof[2]
+		//	 + m[0][3] * DetCof[3];
+
+		return sse_dot_ps(m[0], DetCof);
+	}
+
+	GLM_FUNC_QUALIFIER __m128 sse_det_ps
+	(
+		__m128 const m[4]
+	)
+	{
+		// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
+
+		//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];
+
+		// First 2 columns
+ 		__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
+ 		__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
+		__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+		// Second 2 columns
+		__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
+		__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
+		__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+		// Columns subtraction
+		__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+		// Last 2 rows
+		__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
+		__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
+		__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+		__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+		//tvec4<T, P> 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));
+
+		__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
+		__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
+		__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+		__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+		__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
+		__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
+		__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+		__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+		__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+		__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
+		__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
+		__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+		__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+		__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+		//return m[0][0] * DetCof[0]
+		//	 + m[0][1] * DetCof[1]
+		//	 + m[0][2] * DetCof[2]
+		//	 + m[0][3] * DetCof[3];
+
+		return sse_dot_ps(m[0], DetCof);
+	}
+
+	GLM_FUNC_QUALIFIER void sse_inverse_ps(__m128 const in[4], __m128 out[4])
+	{
+		__m128 Fac0;
+		{
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac0 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac1;
+		{
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac1 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+
+		__m128 Fac2;
+		{
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac2 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac3;
+		{
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac3 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac4;
+		{
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac4 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac5;
+		{
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac5 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+		__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+		// m[1][0]
+		// m[0][0]
+		// m[0][0]
+		// m[0][0]
+		__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][1]
+		// m[0][1]
+		// m[0][1]
+		// m[0][1]
+		__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][2]
+		// m[0][2]
+		// m[0][2]
+		// m[0][2]
+		__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][3]
+		// m[0][3]
+		// m[0][3]
+		// m[0][3]
+		__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// col0
+		// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+		// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+		// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+		// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+		__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+		__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+		__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+		__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+		__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+		__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+		// col1
+		// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+		// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+		// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+		// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+		__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+		__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+		__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+		__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+		__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+		__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+		// col2
+		// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+		// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+		// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+		// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+		__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+		__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+		__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+		__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+		__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+		__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+		// col3
+		// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+		// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+		// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+		// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+		__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+		__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+		__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+		__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+		__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+		__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+		__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+		//	valType Determinant = m[0][0] * Inverse[0][0] 
+		//						+ m[0][1] * Inverse[1][0] 
+		//						+ m[0][2] * Inverse[2][0] 
+		//						+ m[0][3] * Inverse[3][0];
+		__m128 Det0 = sse_dot_ps(in[0], Row2);
+		__m128 Rcp0 = _mm_div_ps(one, Det0);
+		//__m128 Rcp0 = _mm_rcp_ps(Det0);
+
+		//	Inverse /= Determinant;
+		out[0] = _mm_mul_ps(Inv0, Rcp0);
+		out[1] = _mm_mul_ps(Inv1, Rcp0);
+		out[2] = _mm_mul_ps(Inv2, Rcp0);
+		out[3] = _mm_mul_ps(Inv3, Rcp0);
+	}
+
+	GLM_FUNC_QUALIFIER void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
+	{
+		__m128 Fac0;
+		{
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+			//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac0 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac1;
+		{
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+			//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac1 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+
+		__m128 Fac2;
+		{
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+			//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac2 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac3;
+		{
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+			//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac3 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac4;
+		{
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+			//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac4 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 Fac5;
+		{
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+			//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+			//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+			__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+			__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+			__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+			__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+			__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+			__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+			__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+			Fac5 = _mm_sub_ps(Mul00, Mul01);
+		}
+
+		__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+		__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+		// m[1][0]
+		// m[0][0]
+		// m[0][0]
+		// m[0][0]
+		__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][1]
+		// m[0][1]
+		// m[0][1]
+		// m[0][1]
+		__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][2]
+		// m[0][2]
+		// m[0][2]
+		// m[0][2]
+		__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// m[1][3]
+		// m[0][3]
+		// m[0][3]
+		// m[0][3]
+		__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+		// col0
+		// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+		// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+		// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+		// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+		__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+		__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+		__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+		__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+		__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+		__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+		// col1
+		// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+		// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+		// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+		// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+		__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+		__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+		__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+		__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+		__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+		__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+		// col2
+		// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+		// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+		// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+		// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+		__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+		__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+		__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+		__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+		__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+		__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+		// col3
+		// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+		// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+		// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+		// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+		__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+		__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+		__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+		__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+		__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+		__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+		__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+		//	valType Determinant = m[0][0] * Inverse[0][0] 
+		//						+ m[0][1] * Inverse[1][0] 
+		//						+ m[0][2] * Inverse[2][0] 
+		//						+ m[0][3] * Inverse[3][0];
+		__m128 Det0 = sse_dot_ps(in[0], Row2);
+		__m128 Rcp0 = _mm_rcp_ps(Det0);
+		//__m128 Rcp0 = _mm_div_ps(one, Det0);
+		//	Inverse /= Determinant;
+		out[0] = _mm_mul_ps(Inv0, Rcp0);
+		out[1] = _mm_mul_ps(Inv1, Rcp0);
+		out[2] = _mm_mul_ps(Inv2, Rcp0);
+		out[3] = _mm_mul_ps(Inv3, Rcp0);
+	}
+	/*
+	GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
+	{
+		float a = glm::radians(Angle);
+		float c = cos(a);
+		float s = sin(a);
+
+		glm::vec4 AxisA(v[0], v[1], v[2], float(0));
+		__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
+		__m128 AxisC = detail::sse_nrm_ps(AxisB);
+
+		__m128 Cos0 = _mm_set_ss(c);
+		__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Sin0 = _mm_set_ss(s);
+		__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
+
+		// tvec3<T, P> temp = (valType(1) - c) * axis;
+		__m128 Temp0 = _mm_sub_ps(one, CosA);
+		__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
+	
+		//Rotate[0][0] = c + temp[0] * axis[0];
+		//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+		//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+		__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
+		__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
+		__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
+		__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
+		__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
+		__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
+		__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
+
+		//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+		//Rotate[1][1] = c + temp[1] * axis[1];
+		//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+		__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
+		__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
+		__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
+		__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
+		__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
+		__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
+		__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
+
+		//Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+		//Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+		//Rotate[2][2] = c + temp[2] * axis[2];
+		__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
+		__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
+		__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
+		__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
+		__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
+		__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
+		__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
+
+		__m128 Result[4];
+		Result[0] = TmpA4;
+		Result[1] = TmpB4;
+		Result[2] = TmpC4;
+		Result[3] = _mm_set_ps(1, 0, 0, 0);
+
+		//tmat4x4<valType> Result(uninitialize);
+		//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+		//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+		//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+		//Result[3] = m[3];
+		//return Result;
+		sse_mul_ps(in, Result, out);
+	}
+	*/
+	GLM_FUNC_QUALIFIER void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
+	{
+		out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
+		out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
+		out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
+		out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
+	}
+}//namespace detail
+
 	template <>
 	GLM_FUNC_QUALIFIER tmat4x4<float, simd> inverse(tmat4x4<float, simd> const& m)
 	{

glm/detail/intrinsic_common.hpp

@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_common.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_common.inl

@@ -1,137 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_common.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-/*
-	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);
-*/
-}//namespace detail
-}//namespace glms
-

glm/detail/intrinsic_exponential.hpp

@@ -1,77 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_exponential.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_exponential.inl

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_exponential.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

glm/detail/intrinsic_geometric.hpp

@@ -1,74 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_geometric.hpp
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_geometric.inl

@@ -1,149 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/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_AVX)
-		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
-*/
-

glm/detail/intrinsic_integer.hpp

@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2012 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/detail/intrinsic_integer.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "glm/glm.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-	__m128i _mm_bit_interleave_si128(__m128i x);
-	__m128i _mm_bit_interleave_si128(__m128i x, __m128i y);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_integer.inl"
-
-#endif//GLM_ARCH

glm/detail/intrinsic_matrix.hpp

@@ -1,67 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_common.hpp
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_matrix.inl

@@ -1,1070 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_common.inl
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-static const __m128 GLM_VAR_USED _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
-static const __m128 GLM_VAR_USED _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
-
-template <typename matType>
-GLM_FUNC_QUALIFIER matType sse_comp_mul_ps
-(
-	__m128 const in1[4],
-	__m128 const in2[4],
-	__m128 out[4]
-)
-{
-	out[0] = _mm_mul_ps(in1[0], in2[0]);
-	out[1] = _mm_mul_ps(in1[1], in2[1]);
-	out[2] = _mm_mul_ps(in1[2], in2[2]);
-	out[3] = _mm_mul_ps(in1[3], in2[3]);
-}
-
-GLM_FUNC_QUALIFIER void sse_add_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_add_ps(in1[0], in2[0]);
-		out[1] = _mm_add_ps(in1[1], in2[1]);
-		out[2] = _mm_add_ps(in1[2], in2[2]);
-		out[3] = _mm_add_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_sub_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_sub_ps(in1[0], in2[0]);
-		out[1] = _mm_sub_ps(in1[1], in2[1]);
-		out[2] = _mm_sub_ps(in1[2], in2[2]);
-		out[3] = _mm_sub_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 const m[4], __m128 v)
-{
-	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
-
-	__m128 m0 = _mm_mul_ps(m[0], v0);
-	__m128 m1 = _mm_mul_ps(m[1], v1);
-	__m128 m2 = _mm_mul_ps(m[2], v2);
-	__m128 m3 = _mm_mul_ps(m[3], v3);
-
-	__m128 a0 = _mm_add_ps(m0, m1);
-	__m128 a1 = _mm_add_ps(m2, m3);
-	__m128 a2 = _mm_add_ps(a0, a1);
-
-	return a2;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 v, __m128 const m[4])
-{
-	__m128 i0 = m[0];
-	__m128 i1 = m[1];
-	__m128 i2 = m[2];
-	__m128 i3 = m[3];
-
-	__m128 m0 = _mm_mul_ps(v, i0);
-	__m128 m1 = _mm_mul_ps(v, i1);
-	__m128 m2 = _mm_mul_ps(v, i2);
-	__m128 m3 = _mm_mul_ps(v, i3);
-
-	__m128 u0 = _mm_unpacklo_ps(m0, m1);
-	__m128 u1 = _mm_unpackhi_ps(m0, m1);
-	__m128 a0 = _mm_add_ps(u0, u1);
-
-	__m128 u2 = _mm_unpacklo_ps(m2, m3);
-	__m128 u3 = _mm_unpackhi_ps(m2, m3);
-	__m128 a1 = _mm_add_ps(u2, u3);
-
-	__m128 f0 = _mm_movelh_ps(a0, a1);
-	__m128 f1 = _mm_movehl_ps(a1, a0);
-	__m128 f2 = _mm_add_ps(f0, f1);
-
-	return f2;
-}
-
-GLM_FUNC_QUALIFIER void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[0] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[1] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[2] = a2;
-	}
-
-	{
-		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
-		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[3] = a2;
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_transpose_ps(__m128 const in[4], __m128 out[4])
-{
-    __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
-    __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
-    __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
-    __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
-
-    out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
-    out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
-    out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
-    out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_slow_det_ps(__m128 const in[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0]
-	//						+ m[0][1] * Inverse[1][0]
-	//						+ m[0][2] * Inverse[2][0]
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	return Det0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_detd_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
-
-	//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];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
- 	__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
-	__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//tvec4<T, P> 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));
-
-	__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
-	__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
-	__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_det_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
-
-	//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];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
- 	__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
-	__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//tvec4<T, P> 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));
-
-	__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
-	__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
-	__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//__m128 Rcp0 = _mm_rcp_ps(Det0);
-
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_rcp_ps(Det0);
-	//__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-/*
-GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
-{
-	float a = glm::radians(Angle);
-    float c = cos(a);
-    float s = sin(a);
-
-	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
-	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
-    __m128 AxisC = detail::sse_nrm_ps(AxisB);
-
-	__m128 Cos0 = _mm_set_ss(c);
-	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Sin0 = _mm_set_ss(s);
-	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
-
-	// tvec3<T, P> temp = (valType(1) - c) * axis;
-	__m128 Temp0 = _mm_sub_ps(one, CosA);
-	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
-	
-	//Rotate[0][0] = c + temp[0] * axis[0];
-	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
-	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
-	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
-	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
-	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
-	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
-	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
-
-	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
-	//Rotate[1][1] = c + temp[1] * axis[1];
-	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
-	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
-	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
-	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
-	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
-	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
-	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
-	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
-
-    //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-    //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-    //Rotate[2][2] = c + temp[2] * axis[2];
-	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
-	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
-	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
-	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
-	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
-	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
-	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
-
-	__m128 Result[4];
-	Result[0] = TmpA4;
-	Result[1] = TmpB4;
-	Result[2] = TmpC4;
-	Result[3] = _mm_set_ps(1, 0, 0, 0);
-
-	//tmat4x4<valType> Result(uninitialize);
-	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-	//Result[3] = m[3];
-	//return Result;
-	sse_mul_ps(in, Result, out);
-}
-*/
-GLM_FUNC_QUALIFIER void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
-{
-	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
-	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
-	out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
-	out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
-}
-
-}//namespace detail
-}//namespace glm

glm/detail/intrinsic_trigonometric.hpp

@@ -1,46 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_trigonometric.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_trigonometric.inl

@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_trigonometric.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

glm/detail/intrinsic_vector_relational.hpp

@@ -1,46 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_vector_relational.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#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

glm/detail/intrinsic_vector_relational.inl

@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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/detail/intrinsic_vector_relational.inl
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-//
-//// lessThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//    return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename 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 tvec2<T, P>::bool_type lessThanEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename 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 tvec2<T, P>::bool_type greaterThan
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename 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 tvec2<T, P>::bool_type greaterThanEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename 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 tvec2<T, P>::bool_type equal
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> 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 tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> 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 tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> 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 tvec4<T, P>::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 tvec2<T, P>::bool_type notEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> 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 tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> 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 tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> 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 tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
-//}
-//
-//// any
-//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
-//{
-//	return x.x || x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
-//{
-//    return x.x || x.y || x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(tvec4<bool> const & x)
-//{
-//    return x.x || x.y || x.z || x.w;
-//}
-//
-//// all
-//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
-//{
-//    return x.x && x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
-//{
-//    return x.x && x.y && x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
-//{
-//    return x.x && x.y && x.z && x.w;
-//}
-//
-//// not
-//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
-//(
-//	tvec2<bool> const & v
-//)
-//{
-//    return tvec2<bool>::bool_type(!v.x, !v.y);
-//}
-//
-//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
-//(
-//	tvec3<bool> const & v
-//)
-//{
-//    return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
-//}
-//
-//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
-//(
-//	tvec4<bool> const & v
-//)
-//{
-//    return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
-//}

glm/detail/setup.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-///
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-///
-/// 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/detail/setup.hpp
-/// @date 2006-11-13 / 2014-10-05
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/detail/type_vec4_avx.inl

@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/type_tvec4_avx.inl
-/// @date 2014-12-01 / 2014-12-01
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-
-	
-
-}//namespace glm

glm/detail/type_vec4_avx2.inl

@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/detail/type_tvec4_avx2.inl
-/// @date 2014-12-01 / 2014-12-01
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-
-	
-
-}//namespace glm

glm/ext.hpp

@@ -1,32 +1,4 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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
+/// @file glm/ext.hpp
 ///
 /// @ref core (Dependence)
 /// 
@@ -52,7 +24,6 @@
 /// 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.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/gtc/epsilon.hpp

@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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)
@@ -39,7 +11,6 @@
 /// @brief Comparison functions for a user defined epsilon values.
 /// 
 /// <glm/gtc/epsilon.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 

glm/vec4.hpp

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 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.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// 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/vec4.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once