diff options
| author | Joursoir <chat@joursoir.net> | 2021-04-10 17:29:02 +0000 |
|---|---|---|
| committer | Joursoir <chat@joursoir.net> | 2021-04-10 17:29:02 +0000 |
| commit | a8b3118e8305fd1c668ea25e07157b625c9747ff (patch) | |
| tree | 69aeec3c40e123443675da381774ef656a2c86e0 /src/include/glm/detail | |
| parent | 887314d01046ed2c00db3eb7b4b227f070501aa1 (diff) | |
| download | space-simulator-a8b3118e8305fd1c668ea25e07157b625c9747ff.tar.gz space-simulator-a8b3118e8305fd1c668ea25e07157b625c9747ff.tar.bz2 space-simulator-a8b3118e8305fd1c668ea25e07157b625c9747ff.zip | |
add glm headers
Diffstat (limited to 'src/include/glm/detail')
61 files changed, 20949 insertions, 0 deletions
diff --git a/src/include/glm/detail/_features.hpp b/src/include/glm/detail/_features.hpp new file mode 100644 index 0000000..4306951 --- /dev/null +++ b/src/include/glm/detail/_features.hpp @@ -0,0 +1,394 @@ +#pragma once
+
+// #define GLM_CXX98_EXCEPTIONS
+// #define GLM_CXX98_RTTI
+
+// #define GLM_CXX11_RVALUE_REFERENCES
+// Rvalue references - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
+// GLM_CXX11_TRAILING_RETURN
+// Rvalue references for *this - GCC not supported
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Initialization of class objects by rvalues - GCC any
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Non-static data member initializers - GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
+// #define GLM_CXX11_VARIADIC_TEMPLATE
+// Variadic templates - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
+//
+// Extending variadic template template parameters - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
+// #define GLM_CXX11_GENERALIZED_INITIALIZERS
+// Initializer lists - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
+// #define GLM_CXX11_STATIC_ASSERT
+// Static assertions - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
+// #define GLM_CXX11_AUTO_TYPE
+// auto-typed variables - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Multi-declarator auto - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Removal of auto as a storage-class specifier - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
+// #define GLM_CXX11_AUTO_TYPE
+// New function declarator syntax - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
+// #define GLM_CXX11_LAMBDAS
+// New wording for C++0x lambdas - GCC 4.5
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
+// #define GLM_CXX11_DECLTYPE
+// Declared type of an expression - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
+//
+// Right angle brackets - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
+//
+// Default template arguments for function templates DR226 GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
+//
+// Solving the SFINAE problem for expressions DR339 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
+// #define GLM_CXX11_ALIAS_TEMPLATE
+// Template aliases N2258 GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
+//
+// Extern templates N1987 Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
+// #define GLM_CXX11_NULLPTR
+// Null pointer constant N2431 GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
+// #define GLM_CXX11_STRONG_ENUMS
+// Strongly-typed enums N2347 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
+//
+// Forward declarations for enums N2764 GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
+//
+// Generalized attributes N2761 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
+//
+// Generalized constant expressions N2235 GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
+//
+// Alignment support N2341 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
+// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+// Delegating constructors N1986 GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
+//
+// Inheriting constructors N2540 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
+// #define GLM_CXX11_EXPLICIT_CONVERSIONS
+// Explicit conversion operators N2437 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
+//
+// New character types N2249 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
+//
+// Unicode string literals N2442 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Raw string literals N2442 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+//
+// Universal character name literals N2170 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
+// #define GLM_CXX11_USER_LITERALS
+// User-defined literals N2765 GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
+//
+// Standard Layout Types N2342 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
+// #define GLM_CXX11_DEFAULTED_FUNCTIONS
+// #define GLM_CXX11_DELETED_FUNCTIONS
+// Defaulted and deleted functions N2346 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
+//
+// Extended friend declarations N1791 GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
+//
+// Extending sizeof N2253 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
+// #define GLM_CXX11_INLINE_NAMESPACES
+// Inline namespaces N2535 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
+// #define GLM_CXX11_UNRESTRICTED_UNIONS
+// Unrestricted unions N2544 GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
+// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+// Local and unnamed types as template arguments N2657 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
+// #define GLM_CXX11_RANGE_FOR
+// Range-based for N2930 GCC 4.6
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
+// #define GLM_CXX11_OVERRIDE_CONTROL
+// Explicit virtual overrides N2928 N3206 N3272 GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
+//
+// Minimal support for garbage collection and reachability-based leak detection N2670 No
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
+// #define GLM_CXX11_NOEXCEPT
+// Allowing move constructors to throw [noexcept] N3050 GCC 4.6 (core language only)
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
+//
+// Defining move special member functions N3053 GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
+//
+// Sequence points N2239 Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Atomic operations N2427 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+//
+// Strong Compare and Exchange N2748 GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+//
+// Bidirectional Fences N2752 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
+//
+// Memory model N2429 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
+//
+// Data-dependency ordering: atomics and memory model N2664 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
+//
+// Propagating exceptions N2179 GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
+//
+// Abandoning a process and at_quick_exit N2440 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
+//
+// Allow atomics use in signal handlers N2547 Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
+//
+// Thread-local storage N2659 GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
+//
+// Dynamic initialization and destruction with concurrency N2660 GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
+//
+// __func__ predefined identifier N2340 GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
+//
+// C99 preprocessor N1653 GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
+//
+// long long N1811 GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
+//
+// Extended integral types N1988 Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
+#if(GLM_COMPILER & GLM_COMPILER_GCC)
+
+# define GLM_CXX11_STATIC_ASSERT
+
+#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+# if(__has_feature(cxx_exceptions))
+# define GLM_CXX98_EXCEPTIONS
+# endif
+
+# if(__has_feature(cxx_rtti))
+# define GLM_CXX98_RTTI
+# endif
+
+# if(__has_feature(cxx_access_control_sfinae))
+# define GLM_CXX11_ACCESS_CONTROL_SFINAE
+# endif
+
+# if(__has_feature(cxx_alias_templates))
+# define GLM_CXX11_ALIAS_TEMPLATE
+# endif
+
+# if(__has_feature(cxx_alignas))
+# define GLM_CXX11_ALIGNAS
+# endif
+
+# if(__has_feature(cxx_attributes))
+# define GLM_CXX11_ATTRIBUTES
+# endif
+
+# if(__has_feature(cxx_constexpr))
+# define GLM_CXX11_CONSTEXPR
+# endif
+
+# if(__has_feature(cxx_decltype))
+# define GLM_CXX11_DECLTYPE
+# endif
+
+# if(__has_feature(cxx_default_function_template_args))
+# define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+# endif
+
+# if(__has_feature(cxx_defaulted_functions))
+# define GLM_CXX11_DEFAULTED_FUNCTIONS
+# endif
+
+# if(__has_feature(cxx_delegating_constructors))
+# define GLM_CXX11_DELEGATING_CONSTRUCTORS
+# endif
+
+# if(__has_feature(cxx_deleted_functions))
+# define GLM_CXX11_DELETED_FUNCTIONS
+# endif
+
+# if(__has_feature(cxx_explicit_conversions))
+# define GLM_CXX11_EXPLICIT_CONVERSIONS
+# endif
+
+# if(__has_feature(cxx_generalized_initializers))
+# define GLM_CXX11_GENERALIZED_INITIALIZERS
+# endif
+
+# if(__has_feature(cxx_implicit_moves))
+# define GLM_CXX11_IMPLICIT_MOVES
+# endif
+
+# if(__has_feature(cxx_inheriting_constructors))
+# define GLM_CXX11_INHERITING_CONSTRUCTORS
+# endif
+
+# if(__has_feature(cxx_inline_namespaces))
+# define GLM_CXX11_INLINE_NAMESPACES
+# endif
+
+# if(__has_feature(cxx_lambdas))
+# define GLM_CXX11_LAMBDAS
+# endif
+
+# if(__has_feature(cxx_local_type_template_args))
+# define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+# endif
+
+# if(__has_feature(cxx_noexcept))
+# define GLM_CXX11_NOEXCEPT
+# endif
+
+# if(__has_feature(cxx_nonstatic_member_init))
+# define GLM_CXX11_NONSTATIC_MEMBER_INIT
+# endif
+
+# if(__has_feature(cxx_nullptr))
+# define GLM_CXX11_NULLPTR
+# endif
+
+# if(__has_feature(cxx_override_control))
+# define GLM_CXX11_OVERRIDE_CONTROL
+# endif
+
+# if(__has_feature(cxx_reference_qualified_functions))
+# define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+# endif
+
+# if(__has_feature(cxx_range_for))
+# define GLM_CXX11_RANGE_FOR
+# endif
+
+# if(__has_feature(cxx_raw_string_literals))
+# define GLM_CXX11_RAW_STRING_LITERALS
+# endif
+
+# if(__has_feature(cxx_rvalue_references))
+# define GLM_CXX11_RVALUE_REFERENCES
+# endif
+
+# if(__has_feature(cxx_static_assert))
+# define GLM_CXX11_STATIC_ASSERT
+# endif
+
+# if(__has_feature(cxx_auto_type))
+# define GLM_CXX11_AUTO_TYPE
+# endif
+
+# if(__has_feature(cxx_strong_enums))
+# define GLM_CXX11_STRONG_ENUMS
+# endif
+
+# if(__has_feature(cxx_trailing_return))
+# define GLM_CXX11_TRAILING_RETURN
+# endif
+
+# if(__has_feature(cxx_unicode_literals))
+# define GLM_CXX11_UNICODE_LITERALS
+# endif
+
+# if(__has_feature(cxx_unrestricted_unions))
+# define GLM_CXX11_UNRESTRICTED_UNIONS
+# endif
+
+# if(__has_feature(cxx_user_literals))
+# define GLM_CXX11_USER_LITERALS
+# endif
+
+# if(__has_feature(cxx_variadic_templates))
+# define GLM_CXX11_VARIADIC_TEMPLATES
+# endif
+
+#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
diff --git a/src/include/glm/detail/_fixes.hpp b/src/include/glm/detail/_fixes.hpp new file mode 100644 index 0000000..b1f06c2 --- /dev/null +++ b/src/include/glm/detail/_fixes.hpp @@ -0,0 +1,27 @@ +#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+
diff --git a/src/include/glm/detail/_noise.hpp b/src/include/glm/detail/_noise.hpp new file mode 100644 index 0000000..2a1285f --- /dev/null +++ b/src/include/glm/detail/_noise.hpp @@ -0,0 +1,81 @@ +#pragma once
+
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+ template<typename T>
+ GLM_FUNC_QUALIFIER T mod289(T const& x)
+ {
+ return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
+ }
+
+ template<typename T>
+ GLM_FUNC_QUALIFIER T permute(T const& x)
+ {
+ return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
+ {
+ return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
+ {
+ return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
+ {
+ return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+ }
+
+ template<typename T>
+ GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
+ {
+ return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
+ {
+ return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
+ {
+ return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
+ {
+ return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
+ {
+ return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
+ {
+ return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
+ {
+ return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
+ }
+}//namespace detail
+}//namespace glm
+
diff --git a/src/include/glm/detail/_swizzle.hpp b/src/include/glm/detail/_swizzle.hpp new file mode 100644 index 0000000..67c66b1 --- /dev/null +++ b/src/include/glm/detail/_swizzle.hpp @@ -0,0 +1,804 @@ +#pragma once
+
+namespace glm{
+namespace detail
+{
+ // Internal class for implementing swizzle operators
+ template<typename T, int N>
+ struct _swizzle_base0
+ {
+ protected:
+ GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>(_buffer))[i]; }
+ GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast<const T*>(_buffer))[i]; }
+
+ // Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+ // The size 1 buffer is assumed to aligned to the actual members so that the
+ // elem()
+ char _buffer[1];
+ };
+
+ template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+ struct _swizzle_base1 : public _swizzle_base0<T, N>
+ {
+ };
+
+ template<typename T, qualifier Q, int E0, int E1, bool Aligned>
+ struct _swizzle_base1<2, T, Q, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
+ {
+ GLM_FUNC_QUALIFIER vec<2, T, Q> operator ()() const { return vec<2, T, Q>(this->elem(E0), this->elem(E1)); }
+ };
+
+ template<typename T, qualifier Q, int E0, int E1, int E2, bool Aligned>
+ struct _swizzle_base1<3, T, Q, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
+ {
+ GLM_FUNC_QUALIFIER vec<3, T, Q> operator ()() const { return vec<3, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2)); }
+ };
+
+ template<typename T, qualifier Q, int E0, int E1, int E2, int E3, bool Aligned>
+ struct _swizzle_base1<4, T, Q, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
+ {
+ GLM_FUNC_QUALIFIER vec<4, T, Q> operator ()() const { return vec<4, T, Q>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+ };
+
+ // Internal class for implementing swizzle operators
+ /*
+ Template parameters:
+
+ T = type of scalar values (e.g. float, double)
+ N = number of components in the vector (e.g. 3)
+ E0...3 = what index the n-th element of this swizzle refers to in the unswizzled vec
+
+ DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+ containing duplicate elements so that they cannot be used as r-values).
+ */
+ template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+ struct _swizzle_base2 : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+ {
+ struct op_equal
+ {
+ GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e = t; }
+ };
+
+ struct op_minus
+ {
+ GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e -= t; }
+ };
+
+ struct op_plus
+ {
+ GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e += t; }
+ };
+
+ struct op_mul
+ {
+ GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e *= t; }
+ };
+
+ struct op_div
+ {
+ GLM_FUNC_QUALIFIER void operator() (T& e, T& t) const{ e /= t; }
+ };
+
+ public:
+ GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
+ {
+ for (int i = 0; i < N; ++i)
+ (*this)[i] = t;
+ return *this;
+ }
+
+ GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, Q> const& that)
+ {
+ _apply_op(that, op_equal());
+ return *this;
+ }
+
+ GLM_FUNC_QUALIFIER void operator -= (vec<N, T, Q> const& that)
+ {
+ _apply_op(that, op_minus());
+ }
+
+ GLM_FUNC_QUALIFIER void operator += (vec<N, T, Q> const& that)
+ {
+ _apply_op(that, op_plus());
+ }
+
+ GLM_FUNC_QUALIFIER void operator *= (vec<N, T, Q> const& that)
+ {
+ _apply_op(that, op_mul());
+ }
+
+ GLM_FUNC_QUALIFIER void operator /= (vec<N, T, Q> const& that)
+ {
+ _apply_op(that, op_div());
+ }
+
+ GLM_FUNC_QUALIFIER T& operator[](size_t i)
+ {
+ const int offset_dst[4] = { E0, E1, E2, E3 };
+ return this->elem(offset_dst[i]);
+ }
+ GLM_FUNC_QUALIFIER T operator[](size_t i) const
+ {
+ const int offset_dst[4] = { E0, E1, E2, E3 };
+ return this->elem(offset_dst[i]);
+ }
+
+ protected:
+ template<typename U>
+ GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, Q> const& that, const U& op)
+ {
+ // Make a copy of the data in this == &that.
+ // The copier should optimize out the copy in cases where the function is
+ // properly inlined and the copy is not necessary.
+ T t[N];
+ for (int i = 0; i < N; ++i)
+ t[i] = that[i];
+ for (int i = 0; i < N; ++i)
+ op( (*this)[i], t[i] );
+ }
+ };
+
+ // Specialization for swizzles containing duplicate elements. These cannot be modified.
+ template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+ struct _swizzle_base2<N, T, Q, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, Q, E0,E1,E2,E3, detail::is_aligned<Q>::value>
+ {
+ struct Stub {};
+
+ GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const&) { return *this; }
+
+ GLM_FUNC_QUALIFIER T operator[] (size_t i) const
+ {
+ const int offset_dst[4] = { E0, E1, E2, E3 };
+ return this->elem(offset_dst[i]);
+ }
+ };
+
+ template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+ struct _swizzle : public _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
+ {
+ typedef _swizzle_base2<N, T, Q, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
+
+ using base_type::operator=;
+
+ GLM_FUNC_QUALIFIER operator vec<N, T, Q> () const { return (*this)(); }
+ };
+
+//
+// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+//
+#define GLM_SWIZZLE_TEMPLATE1 template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3>
+#define GLM_SWIZZLE_TEMPLATE2 template<int N, typename T, qualifier Q, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define GLM_SWIZZLE_TYPE1 _swizzle<N, T, Q, E0, E1, E2, E3>
+#define GLM_SWIZZLE_TYPE2 _swizzle<N, T, Q, F0, F1, F2, F3>
+
+//
+// Wrapper for a binary operator (e.g. u.yy + v.zy)
+//
+#define GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
+ GLM_SWIZZLE_TEMPLATE2 \
+ GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+ { \
+ return a() OPERAND b(); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const vec<N, T, Q>& b) \
+ { \
+ return a() OPERAND b; \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const vec<N, T, Q>& a, const GLM_SWIZZLE_TYPE1& b) \
+ { \
+ return a OPERAND b(); \
+ }
+
+//
+// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+//
+#define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \
+ { \
+ return a() OPERAND b; \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER vec<N, T, Q> operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b) \
+ { \
+ return a OPERAND b(); \
+ }
+
+//
+// Macro for wrapping a function taking one argument (e.g. abs())
+//
+#define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a) \
+ { \
+ return FUNCTION(a()); \
+ }
+
+//
+// Macro for wrapping a function taking two vector arguments (e.g. dot()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \
+ GLM_SWIZZLE_TEMPLATE2 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \
+ { \
+ return FUNCTION(a(), b()); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \
+ { \
+ return FUNCTION(a(), b()); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b) \
+ { \
+ return FUNCTION(a(), b); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b) \
+ { \
+ return FUNCTION(a, b()); \
+ }
+
+//
+// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+//
+#define GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \
+ GLM_SWIZZLE_TEMPLATE2 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b, const T& c) \
+ { \
+ return FUNCTION(a(), b(), c); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \
+ { \
+ return FUNCTION(a(), b(), c); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+ { \
+ return FUNCTION(a(), b, c); \
+ } \
+ GLM_SWIZZLE_TEMPLATE1 \
+ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const GLM_SWIZZLE_TYPE1& b, const T& c) \
+ { \
+ return FUNCTION(a, b(), c); \
+ }
+
+}//namespace detail
+}//namespace glm
+
+namespace glm
+{
+ namespace detail
+ {
+ GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+ GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+ GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+ GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+ GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+ GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+ }
+
+ //
+ // Swizzles are distinct types from the unswizzled type. The below macros will
+ // provide template specializations for the swizzle types for the given functions
+ // so that the compiler does not have any ambiguity to choosing how to handle
+ // the function.
+ //
+ // The alternative is to use the operator()() when calling the function in order
+ // to explicitly convert the swizzled type to the unswizzled type.
+ //
+
+ //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, abs);
+ //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acos);
+ //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, acosh);
+ //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, all);
+ //GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type, any);
+
+ //GLM_SWIZZLE_FUNCTION_2_ARGS(value_type, dot);
+ //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, cross);
+ //GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type, step);
+ //GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+}
+
+#define GLM_SWIZZLE2_2_MEMBERS(T, Q, E0,E1) \
+ struct { detail::_swizzle<2, T, Q, 0,0,-1,-2> E0 ## E0; }; \
+ struct { detail::_swizzle<2, T, Q, 0,1,-1,-2> E0 ## E1; }; \
+ struct { detail::_swizzle<2, T, Q, 1,0,-1,-2> E1 ## E0; }; \
+ struct { detail::_swizzle<2, T, Q, 1,1,-1,-2> E1 ## E1; };
+
+#define GLM_SWIZZLE2_3_MEMBERS(T, Q, E0,E1) \
+ struct { detail::_swizzle<3,T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3,T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3,T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3,T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3,T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3,T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3,T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3,T, Q, 1,1,1,-1> E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE2_4_MEMBERS(T, Q, E0,E1) \
+ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
+
+#define GLM_SWIZZLE3_2_MEMBERS(T, Q, E0,E1,E2) \
+ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; };
+
+#define GLM_SWIZZLE3_3_MEMBERS(T, Q ,E0,E1,E2) \
+ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE3_4_MEMBERS(T, Q, E0,E1,E2) \
+ struct { detail::_swizzle<4,T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4,T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; };
+
+#define GLM_SWIZZLE4_2_MEMBERS(T, Q, E0,E1,E2,E3) \
+ struct { detail::_swizzle<2,T, Q, 0,0,-1,-2> E0 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 0,1,-1,-2> E0 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 0,2,-1,-2> E0 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 0,3,-1,-2> E0 ## E3; }; \
+ struct { detail::_swizzle<2,T, Q, 1,0,-1,-2> E1 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 1,1,-1,-2> E1 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 1,2,-1,-2> E1 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 1,3,-1,-2> E1 ## E3; }; \
+ struct { detail::_swizzle<2,T, Q, 2,0,-1,-2> E2 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 2,1,-1,-2> E2 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 2,2,-1,-2> E2 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 2,3,-1,-2> E2 ## E3; }; \
+ struct { detail::_swizzle<2,T, Q, 3,0,-1,-2> E3 ## E0; }; \
+ struct { detail::_swizzle<2,T, Q, 3,1,-1,-2> E3 ## E1; }; \
+ struct { detail::_swizzle<2,T, Q, 3,2,-1,-2> E3 ## E2; }; \
+ struct { detail::_swizzle<2,T, Q, 3,3,-1,-2> E3 ## E3; };
+
+#define GLM_SWIZZLE4_3_MEMBERS(T, Q, E0,E1,E2,E3) \
+ struct { detail::_swizzle<3, T, Q, 0,0,0,-1> E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,0,1,-1> E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,0,2,-1> E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,0,3,-1> E0 ## E0 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,0,-1> E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,1,-1> E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,2,-1> E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,1,3,-1> E0 ## E1 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,0,-1> E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,1,-1> E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,2,-1> E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,2,3,-1> E0 ## E2 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 0,3,0,-1> E0 ## E3 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 0,3,1,-1> E0 ## E3 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 0,3,2,-1> E0 ## E3 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 0,3,3,-1> E0 ## E3 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,0,-1> E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,1,-1> E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,2,-1> E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,0,3,-1> E1 ## E0 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,0,-1> E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,1,-1> E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,2,-1> E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,1,3,-1> E1 ## E1 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,0,-1> E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,1,-1> E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,2,-1> E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,2,3,-1> E1 ## E2 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 1,3,0,-1> E1 ## E3 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 1,3,1,-1> E1 ## E3 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 1,3,2,-1> E1 ## E3 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 1,3,3,-1> E1 ## E3 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,0,-1> E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,1,-1> E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,2,-1> E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,0,3,-1> E2 ## E0 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,0,-1> E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,1,-1> E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,2,-1> E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,1,3,-1> E2 ## E1 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,0,-1> E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,1,-1> E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,2,-1> E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,2,3,-1> E2 ## E2 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 2,3,0,-1> E2 ## E3 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 2,3,1,-1> E2 ## E3 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 2,3,2,-1> E2 ## E3 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 2,3,3,-1> E2 ## E3 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 3,0,0,-1> E3 ## E0 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 3,0,1,-1> E3 ## E0 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 3,0,2,-1> E3 ## E0 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 3,0,3,-1> E3 ## E0 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 3,1,0,-1> E3 ## E1 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 3,1,1,-1> E3 ## E1 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 3,1,2,-1> E3 ## E1 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 3,1,3,-1> E3 ## E1 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 3,2,0,-1> E3 ## E2 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 3,2,1,-1> E3 ## E2 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 3,2,2,-1> E3 ## E2 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 3,2,3,-1> E3 ## E2 ## E3; }; \
+ struct { detail::_swizzle<3, T, Q, 3,3,0,-1> E3 ## E3 ## E0; }; \
+ struct { detail::_swizzle<3, T, Q, 3,3,1,-1> E3 ## E3 ## E1; }; \
+ struct { detail::_swizzle<3, T, Q, 3,3,2,-1> E3 ## E3 ## E2; }; \
+ struct { detail::_swizzle<3, T, Q, 3,3,3,-1> E3 ## E3 ## E3; };
+
+#define GLM_SWIZZLE4_4_MEMBERS(T, Q, E0,E1,E2,E3) \
+ struct { detail::_swizzle<4, T, Q, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+ struct { detail::_swizzle<4, T, Q, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
diff --git a/src/include/glm/detail/_swizzle_func.hpp b/src/include/glm/detail/_swizzle_func.hpp new file mode 100644 index 0000000..f179a23 --- /dev/null +++ b/src/include/glm/detail/_swizzle_func.hpp @@ -0,0 +1,682 @@ +#pragma once
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B) \
+ vec<2, T, Q> A ## B() CONST \
+ { \
+ return vec<2, T, Q>(this->A, this->B); \
+ }
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, CONST, A, B, C) \
+ vec<3, T, Q> A ## B ## C() CONST \
+ { \
+ return vec<3, T, Q>(this->A, this->B, this->C); \
+ }
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, CONST, A, B, C, D) \
+ vec<4, T, Q> A ## B ## C ## D() CONST \
+ { \
+ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \
+ }
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(T, P, L, CONST, A, B) \
+ template<typename T> \
+ vec<L, T, Q> vec<L, T, Q>::A ## B() CONST \
+ { \
+ return vec<2, T, Q>(this->A, this->B); \
+ }
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(T, P, L, CONST, A, B, C) \
+ template<typename T> \
+ vec<3, T, Q> vec<L, T, Q>::A ## B ## C() CONST \
+ { \
+ return vec<3, T, Q>(this->A, this->B, this->C); \
+ }
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(T, P, L, CONST, A, B, C, D) \
+ template<typename T> \
+ vec<4, T, Q> vec<L, T, Q>::A ## B ## C ## D() CONST \
+ { \
+ return vec<4, T, Q>(this->A, this->B, this->C, this->D); \
+ }
+
+#define GLM_MUTABLE
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, 2, GLM_MUTABLE, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(T, P) \
+ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, x, y) \
+ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, r, g) \
+ GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, GLM_MUTABLE, C, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, x, y, z) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, r, g, b) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, A, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, B, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, C, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, GLM_MUTABLE, D, C)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , A, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , B, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , C, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, , D, C, B)
+
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , B, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , C, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, , D, B, C, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, x, y, z, w) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, r, g, b, a) \
+ GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, s, t, p, q)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(T, P, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(T, P, A, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, x, y) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, r, g) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(T, P, s, t)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(T, P, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(T, P, A, B, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, x, y, z) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, r, g, b) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, s, t, p)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, A, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, B, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, C, D) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, A) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, B) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, C) \
+ GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, const, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, A, D, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, B, D, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, C, D, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, A, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, B, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, A) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, B) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, C) \
+ GLM_SWIZZLE_GEN_VEC3_ENTRY(T, P, const, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, A, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, B, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, C, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, A, D, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, A, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, B, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, C, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, B, D, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, A, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, B, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, C, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, C, D, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, A, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, B, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, C, D, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, A, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, B, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, A) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, B) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, C) \
+ GLM_SWIZZLE_GEN_VEC4_ENTRY(T, P, const, D, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(T, P, A, B, C, D) \
+ GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(T, P, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, x, y, z, w) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, r, g, b, a) \
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, s, t, p, q)
+
diff --git a/src/include/glm/detail/_vectorize.hpp b/src/include/glm/detail/_vectorize.hpp new file mode 100644 index 0000000..f7a0cc1 --- /dev/null +++ b/src/include/glm/detail/_vectorize.hpp @@ -0,0 +1,162 @@ +#pragma once
+
+namespace glm{
+namespace detail
+{
+ template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename R, typename T, qualifier Q>
+ struct functor1{};
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+ struct functor1<vec, 1, R, T, Q>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
+ {
+ return vec<1, R, Q>(Func(v.x));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+ struct functor1<vec, 2, R, T, Q>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
+ {
+ return vec<2, R, Q>(Func(v.x), Func(v.y));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+ struct functor1<vec, 3, R, T, Q>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
+ {
+ return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename R, typename T, qualifier Q>
+ struct functor1<vec, 4, R, T, Q>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
+ {
+ return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+ struct functor2{};
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2<vec, 1, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+ {
+ return vec<1, T, Q>(Func(a.x, b.x));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2<vec, 2, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+ {
+ return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2<vec, 3, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+ {
+ return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2<vec, 4, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+ struct functor2_vec_sca{};
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2_vec_sca<vec, 1, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
+ {
+ return vec<1, T, Q>(Func(a.x, b));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2_vec_sca<vec, 2, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
+ {
+ return vec<2, T, Q>(Func(a.x, b), Func(a.y, b));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2_vec_sca<vec, 3, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
+ {
+ return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+ }
+ };
+
+ template<template<length_t L, typename T, qualifier Q> class vec, typename T, qualifier Q>
+ struct functor2_vec_sca<vec, 4, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
+ {
+ return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q>
+ struct functor2_vec_int {};
+
+ template<typename T, qualifier Q>
+ struct functor2_vec_int<1, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<1, int, Q> call(int (*Func) (T x, int y), vec<1, T, Q> const& a, vec<1, int, Q> const& b)
+ {
+ return vec<1, int, Q>(Func(a.x, b.x));
+ }
+ };
+
+ template<typename T, qualifier Q>
+ struct functor2_vec_int<2, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<2, int, Q> call(int (*Func) (T x, int y), vec<2, T, Q> const& a, vec<2, int, Q> const& b)
+ {
+ return vec<2, int, Q>(Func(a.x, b.x), Func(a.y, b.y));
+ }
+ };
+
+ template<typename T, qualifier Q>
+ struct functor2_vec_int<3, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<3, int, Q> call(int (*Func) (T x, int y), vec<3, T, Q> const& a, vec<3, int, Q> const& b)
+ {
+ return vec<3, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+ }
+ };
+
+ template<typename T, qualifier Q>
+ struct functor2_vec_int<4, T, Q>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, int, Q> call(int (*Func) (T x, int y), vec<4, T, Q> const& a, vec<4, int, Q> const& b)
+ {
+ return vec<4, int, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+ }
+ };
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/compute_common.hpp b/src/include/glm/detail/compute_common.hpp new file mode 100644 index 0000000..6bcdd6e --- /dev/null +++ b/src/include/glm/detail/compute_common.hpp @@ -0,0 +1,50 @@ +#pragma once
+
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+ template<typename genFIType, bool /*signed*/>
+ struct compute_abs
+ {};
+
+ template<typename genFIType>
+ struct compute_abs<genFIType, true>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+ {
+ GLM_STATIC_ASSERT(
+ std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+ "'abs' only accept floating-point and integer scalar or vector inputs");
+
+ return x >= genFIType(0) ? x : -x;
+ // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+ }
+ };
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+ template<>
+ struct compute_abs<float, true>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static float call(float x)
+ {
+ return fabsf(x);
+ }
+ };
+#endif
+
+ template<typename genFIType>
+ struct compute_abs<genFIType, false>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
+ {
+ GLM_STATIC_ASSERT(
+ (!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+ "'abs' only accept floating-point and integer scalar or vector inputs");
+ return x;
+ }
+ };
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/compute_vector_relational.hpp b/src/include/glm/detail/compute_vector_relational.hpp new file mode 100644 index 0000000..687b80b --- /dev/null +++ b/src/include/glm/detail/compute_vector_relational.hpp @@ -0,0 +1,30 @@ +#pragma once
+
+//#include "compute_common.hpp"
+#include "setup.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+ template <typename T, bool isFloat>
+ struct compute_equal
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+ {
+ return a == b;
+ }
+ };
+/*
+ template <typename T>
+ struct compute_equal<T, true>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b)
+ {
+ return detail::compute_abs<T, std::numeric_limits<T>::is_signed>::call(b - a) <= static_cast<T>(0);
+ //return std::memcmp(&a, &b, sizeof(T)) == 0;
+ }
+ };
+*/
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/func_common.inl b/src/include/glm/detail/func_common.inl new file mode 100644 index 0000000..7026a77 --- /dev/null +++ b/src/include/glm/detail/func_common.inl @@ -0,0 +1,792 @@ +/// @ref core
+/// @file glm/detail/func_common.inl
+
+#include "../vector_relational.hpp"
+#include "compute_common.hpp"
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+
+namespace glm
+{
+ // min
+ template<typename genType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
+ return (y < x) ? y : x;
+ }
+
+ // max
+ template<typename genType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
+
+ return (x < y) ? y : x;
+ }
+
+ // abs
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x)
+ {
+ int const y = x >> (sizeof(int) * 8 - 1);
+ return (x ^ y) - y;
+ }
+
+ // round
+# if GLM_HAS_CXX11_STL
+ using ::std::round;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType round(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
+
+ return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
+ }
+# endif
+
+ // trunc
+# if GLM_HAS_CXX11_STL
+ using ::std::trunc;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType trunc(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
+
+ return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
+ }
+# endif
+
+}//namespace glm
+
+namespace glm{
+namespace detail
+{
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_abs_vector
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(abs, x);
+ }
+ };
+
+ template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+ struct compute_mix_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+ return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_mix_vector<L, T, bool, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, bool, Q> const& a)
+ {
+ vec<L, T, Q> Result;
+ for(length_t i = 0; i < x.length(); ++i)
+ Result[i] = a[i] ? y[i] : x[i];
+ return Result;
+ }
+ };
+
+ template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
+ struct compute_mix_scalar
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+ return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_mix_scalar<L, T, bool, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, bool const& a)
+ {
+ return a ? y : x;
+ }
+ };
+
+ template<typename T, typename U>
+ struct compute_mix
+ {
+ GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
+
+ return static_cast<T>(static_cast<U>(x) * (static_cast<U>(1) - a) + static_cast<U>(y) * a);
+ }
+ };
+
+ template<typename T>
+ struct compute_mix<T, bool>
+ {
+ GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a)
+ {
+ return a ? y : x;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+ struct compute_sign
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return vec<L, T, Q>(glm::lessThan(vec<L, T, Q>(0), x)) - vec<L, T, Q>(glm::lessThan(x, vec<L, T, Q>(0)));
+ }
+ };
+
+# if GLM_ARCH == GLM_ARCH_X86
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_sign<L, T, Q, false, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
+ vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift));
+
+ return (x >> Shift) | y;
+ }
+ };
+# endif
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_floor
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(std::floor, x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_ceil
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(std::ceil, x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_fract
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return x - floor(x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_trunc
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(trunc, x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_round
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(round, x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_mod
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+ return a - b * floor(a / b);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_min_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ return detail::functor2<vec, L, T, Q>::call(min, x, y);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_max_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ return detail::functor2<vec, L, T, Q>::call(max, x, y);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_clamp_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+ {
+ return min(max(x, minVal), maxVal);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_step_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+ {
+ return mix(vec<L, T, Q>(1), vec<L, T, Q>(0), glm::lessThan(x, edge));
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_smoothstep_vector
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+ vec<L, T, Q> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+ return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+ }
+ };
+}//namespace detail
+
+ template<typename genFIType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType abs(genFIType x)
+ {
+ return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> abs(vec<L, T, Q> const& x)
+ {
+ return detail::compute_abs_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // sign
+ // fast and works for any type
+ template<typename genFIType>
+ GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
+ {
+ GLM_STATIC_ASSERT(
+ std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+ "'sign' only accept signed inputs");
+
+ return detail::compute_sign<1, genFIType, defaultp,
+ std::numeric_limits<genFIType>::is_iec559, detail::is_aligned<highp>::value>::call(vec<1, genFIType>(x)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> sign(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(
+ std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+ "'sign' only accept signed inputs");
+
+ return detail::compute_sign<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // floor
+ using ::std::floor;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> floor(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
+ return detail::compute_floor<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> trunc(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
+ return detail::compute_trunc<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> round(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
+ return detail::compute_round<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+/*
+ // roundEven
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+ return genType(int(x + genType(int(x) % 2)));
+ }
+*/
+
+ // roundEven
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType roundEven(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+ int Integer = static_cast<int>(x);
+ genType IntegerPart = static_cast<genType>(Integer);
+ genType FractionalPart = fract(x);
+
+ if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
+ {
+ return round(x);
+ }
+ else if((Integer % 2) == 0)
+ {
+ return IntegerPart;
+ }
+ else if(x <= static_cast<genType>(0)) // Work around...
+ {
+ return IntegerPart - static_cast<genType>(1);
+ }
+ else
+ {
+ return IntegerPart + static_cast<genType>(1);
+ }
+ //else // Bug on MinGW 4.5.2
+ //{
+ // return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
+ //}
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> roundEven(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
+ return detail::functor1<vec, L, T, T, Q>::call(roundEven, x);
+ }
+
+ // ceil
+ using ::std::ceil;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> ceil(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
+ return detail::compute_ceil<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // fract
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType fract(genType x)
+ {
+ return fract(vec<1, genType>(x)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> fract(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
+ return detail::compute_fract<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // mod
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
+ {
+# if GLM_COMPILER & GLM_COMPILER_CUDA
+ // Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
+ vec<1, genType, defaultp> Result(mod(vec<1, genType, defaultp>(x), y));
+ return Result.x;
+# else
+ return mod(vec<1, genType, defaultp>(x), y).x;
+# endif
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, T y)
+ {
+ return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(y));
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> mod(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ return detail::compute_mod<L, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+ }
+
+ // modf
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
+ return std::modf(x, &i);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<1, T, Q> modf(vec<1, T, Q> const& x, vec<1, T, Q> & i)
+ {
+ return vec<1, T, Q>(
+ modf(x.x, i.x));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<2, T, Q> modf(vec<2, T, Q> const& x, vec<2, T, Q> & i)
+ {
+ return vec<2, T, Q>(
+ modf(x.x, i.x),
+ modf(x.y, i.y));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<3, T, Q> modf(vec<3, T, Q> const& x, vec<3, T, Q> & i)
+ {
+ return vec<3, T, Q>(
+ modf(x.x, i.x),
+ modf(x.y, i.y),
+ modf(x.z, i.z));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<4, T, Q> modf(vec<4, T, Q> const& x, vec<4, T, Q> & i)
+ {
+ return vec<4, T, Q>(
+ modf(x.x, i.x),
+ modf(x.y, i.y),
+ modf(x.z, i.z),
+ modf(x.w, i.w));
+ }
+
+ //// Only valid if (INT_MIN <= x-y <= INT_MAX)
+ //// min(x,y)
+ //r = y + ((x - y) & ((x - y) >> (sizeof(int) *
+ //CHAR_BIT - 1)));
+ //// max(x,y)
+ //r = x - ((x - y) & ((x - y) >> (sizeof(int) *
+ //CHAR_BIT - 1)));
+
+ // min
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, T b)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'min' only accept floating-point or integer inputs");
+ return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+ {
+ return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+ }
+
+ // max
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, T b)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'max' only accept floating-point or integer inputs");
+ return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+ {
+ return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, b);
+ }
+
+ // clamp
+ template<typename genType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
+ return min(max(x, minVal), maxVal);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+ return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(minVal), vec<L, T, Q>(maxVal));
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+ return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, minVal, maxVal);
+ }
+
+ template<typename genTypeT, typename genTypeU>
+ GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
+ {
+ return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
+ }
+
+ template<length_t L, typename T, typename U, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a)
+ {
+ return detail::compute_mix_scalar<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+ }
+
+ template<length_t L, typename T, typename U, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
+ {
+ return detail::compute_mix_vector<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
+ }
+
+ // step
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
+ {
+ return mix(static_cast<genType>(1), static_cast<genType>(0), x < edge);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> step(T edge, vec<L, T, Q> const& x)
+ {
+ return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge), x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> step(vec<L, T, Q> const& edge, vec<L, T, Q> const& x)
+ {
+ return detail::compute_step_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge, x);
+ }
+
+ // smoothstep
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
+
+ genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
+ return tmp * tmp * (genType(3) - genType(2) * tmp);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(T edge0, T edge1, vec<L, T, Q> const& x)
+ {
+ return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(vec<L, T, Q>(edge0), vec<L, T, Q>(edge1), x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> smoothstep(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
+ {
+ return detail::compute_smoothstep_vector<L, T, Q, detail::is_aligned<Q>::value>::call(edge0, edge1, x);
+ }
+
+# if GLM_HAS_CXX11_STL
+ using std::isnan;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER bool isnan(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
+
+# if GLM_HAS_CXX11_STL
+ return std::isnan(x);
+# elif GLM_COMPILER & GLM_COMPILER_VC
+ return _isnan(x) != 0;
+# elif GLM_COMPILER & GLM_COMPILER_INTEL
+# if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+ return _isnan(x) != 0;
+# else
+ return ::isnan(x) != 0;
+# endif
+# elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L
+ return _isnan(x) != 0;
+# elif GLM_COMPILER & GLM_COMPILER_CUDA
+ return ::isnan(x) != 0;
+# else
+ return std::isnan(x);
+# endif
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, bool, Q> isnan(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+ vec<L, bool, Q> Result;
+ for (length_t l = 0; l < v.length(); ++l)
+ Result[l] = glm::isnan(v[l]);
+ return Result;
+ }
+
+# if GLM_HAS_CXX11_STL
+ using std::isinf;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER bool isinf(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
+
+# if GLM_HAS_CXX11_STL
+ return std::isinf(x);
+# elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
+# if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+ return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+# else
+ return ::isinf(x);
+# endif
+# elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
+ return _isinf(x) != 0;
+# else
+ return std::isinf(x);
+# endif
+# elif GLM_COMPILER & GLM_COMPILER_CUDA
+ // http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
+ return ::isinf(double(x)) != 0;
+# else
+ return std::isinf(x);
+# endif
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, bool, Q> isinf(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
+
+ vec<L, bool, Q> Result;
+ for (length_t l = 0; l < v.length(); ++l)
+ Result[l] = glm::isinf(v[l]);
+ return Result;
+ }
+
+ GLM_FUNC_QUALIFIER int floatBitsToInt(float const& v)
+ {
+ union
+ {
+ float in;
+ int out;
+ } u;
+
+ u.in = v;
+
+ return u.out;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, int, Q> floatBitsToInt(vec<L, float, Q> const& v)
+ {
+ return reinterpret_cast<vec<L, int, Q>&>(const_cast<vec<L, float, Q>&>(v));
+ }
+
+ GLM_FUNC_QUALIFIER uint floatBitsToUint(float const& v)
+ {
+ union
+ {
+ float in;
+ uint out;
+ } u;
+
+ u.in = v;
+
+ return u.out;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, uint, Q> floatBitsToUint(vec<L, float, Q> const& v)
+ {
+ return reinterpret_cast<vec<L, uint, Q>&>(const_cast<vec<L, float, Q>&>(v));
+ }
+
+ GLM_FUNC_QUALIFIER float intBitsToFloat(int const& v)
+ {
+ union
+ {
+ int in;
+ float out;
+ } u;
+
+ u.in = v;
+
+ return u.out;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, float, Q> intBitsToFloat(vec<L, int, Q> const& v)
+ {
+ return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, int, Q>&>(v));
+ }
+
+ GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const& v)
+ {
+ union
+ {
+ uint in;
+ float out;
+ } u;
+
+ u.in = v;
+
+ return u.out;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, float, Q> uintBitsToFloat(vec<L, uint, Q> const& v)
+ {
+ return reinterpret_cast<vec<L, float, Q>&>(const_cast<vec<L, uint, Q>&>(v));
+ }
+
+# if GLM_HAS_CXX11_STL
+ using std::fma;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType fma(genType const& a, genType const& b, genType const& c)
+ {
+ return a * b + c;
+ }
+# endif
+
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
+
+ return std::frexp(x, &exp);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+ vec<L, T, Q> Result;
+ for (length_t l = 0; l < v.length(); ++l)
+ Result[l] = std::frexp(v[l], &exp[l]);
+ return Result;
+ }
+
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+ return std::ldexp(x, exp);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+ vec<L, T, Q> Result;
+ for (length_t l = 0; l < v.length(); ++l)
+ Result[l] = std::ldexp(v[l], exp[l]);
+ return Result;
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_common_simd.inl"
+#endif
diff --git a/src/include/glm/detail/func_common_simd.inl b/src/include/glm/detail/func_common_simd.inl new file mode 100644 index 0000000..c04e6e5 --- /dev/null +++ b/src/include/glm/detail/func_common_simd.inl @@ -0,0 +1,231 @@ +/// @ref core
+/// @file glm/detail/func_common_simd.inl
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "../simd/common.h"
+
+#include <immintrin.h>
+
+namespace glm{
+namespace detail
+{
+ template<qualifier Q>
+ struct compute_abs_vector<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_abs(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_abs_vector<4, int, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
+ {
+ vec<4, int, Q> result;
+ result.data = glm_ivec4_abs(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_floor<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_floor(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_ceil<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_ceil(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_fract<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_fract(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_round<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_round(v.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_mod<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+ {
+ vec<4, float, Q> result;
+ result.data = glm_vec4_mod(x.data, y.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_min_vector<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ vec<4, float, Q> result;
+ result.data = _mm_min_ps(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_min_vector<4, int, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ vec<4, int, Q> result;
+ result.data = _mm_min_epi32(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_min_vector<4, uint, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+ {
+ vec<4, uint, Q> result;
+ result.data = _mm_min_epu32(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_max_vector<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ vec<4, float, Q> result;
+ result.data = _mm_max_ps(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_max_vector<4, int, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ vec<4, int, Q> result;
+ result.data = _mm_max_epi32(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_max_vector<4, uint, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+ {
+ vec<4, uint, Q> result;
+ result.data = _mm_max_epu32(v1.data, v2.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_clamp_vector<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal)
+ {
+ vec<4, float, Q> result;
+ result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_clamp_vector<4, int, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& x, vec<4, int, Q> const& minVal, vec<4, int, Q> const& maxVal)
+ {
+ vec<4, int, Q> result;
+ result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_clamp_vector<4, uint, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& x, vec<4, uint, Q> const& minVal, vec<4, uint, Q> const& maxVal)
+ {
+ vec<4, uint, Q> result;
+ result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
+ return result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_mix_vector<4, float, bool, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a)
+ {
+ __m128i const Load = _mm_set_epi32(-static_cast<int>(a.w), -static_cast<int>(a.z), -static_cast<int>(a.y), -static_cast<int>(a.x));
+ __m128 const Mask = _mm_castsi128_ps(Load);
+
+ vec<4, float, Q> Result;
+# if 0 && GLM_ARCH & GLM_ARCH_AVX
+ Result.data = _mm_blendv_ps(x.data, y.data, Mask);
+# else
+ Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
+# endif
+ return Result;
+ }
+ };
+/* FIXME
+ template<qualifier Q>
+ struct compute_step_vector<float, Q, tvec4>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x)
+ {
+ vec<4, float, Q> Result;
+ result.data = glm_vec4_step(edge.data, x.data);
+ return result;
+ }
+ };
+*/
+ template<qualifier Q>
+ struct compute_smoothstep_vector<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x)
+ {
+ vec<4, float, Q> Result;
+ Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
+ return Result;
+ }
+ };
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/src/include/glm/detail/func_exponential.inl b/src/include/glm/detail/func_exponential.inl new file mode 100644 index 0000000..477b377 --- /dev/null +++ b/src/include/glm/detail/func_exponential.inl @@ -0,0 +1,152 @@ +/// @ref core
+/// @file glm/detail/func_exponential.inl
+
+#include "../vector_relational.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+#include <cmath>
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+# if GLM_HAS_CXX11_STL
+ using std::log2;
+# else
+ template<typename genType>
+ genType log2(genType Value)
+ {
+ return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
+ struct compute_log2
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+
+ return detail::functor1<vec, L, T, T, Q>::call(log2, v);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_sqrt
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(std::sqrt, x);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_inversesqrt
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
+ {
+ return static_cast<T>(1) / sqrt(x);
+ }
+ };
+
+ template<length_t L, bool Aligned>
+ struct compute_inversesqrt<L, float, lowp, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const& x)
+ {
+ vec<L, float, lowp> tmp(x);
+ vec<L, float, lowp> xhalf(tmp * 0.5f);
+ vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
+ vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
+ vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
+ tmp = *ptmp;
+ tmp = tmp * (1.5f - xhalf * tmp * tmp);
+ return tmp;
+ }
+ };
+}//namespace detail
+
+ // pow
+ using std::pow;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent)
+ {
+ return detail::functor2<vec, L, T, Q>::call(pow, base, exponent);
+ }
+
+ // exp
+ using std::exp;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> exp(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(exp, x);
+ }
+
+ // log
+ using std::log;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(log, x);
+ }
+
+# if GLM_HAS_CXX11_STL
+ using std::exp2;
+# else
+ //exp2, ln2 = 0.69314718055994530941723212145818f
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType exp2(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
+
+ return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> exp2(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(exp2, x);
+ }
+
+ // log2, ln2 = 0.69314718055994530941723212145818f
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType log2(genType x)
+ {
+ return log2(vec<1, genType>(x)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> log2(vec<L, T, Q> const& x)
+ {
+ return detail::compute_log2<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // sqrt
+ using std::sqrt;
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
+ return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // inversesqrt
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
+ {
+ return static_cast<genType>(1) / sqrt(x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
+ return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_exponential_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/func_exponential_simd.inl b/src/include/glm/detail/func_exponential_simd.inl new file mode 100644 index 0000000..708e10d --- /dev/null +++ b/src/include/glm/detail/func_exponential_simd.inl @@ -0,0 +1,37 @@ +/// @ref core
+/// @file glm/detail/func_exponential_simd.inl
+
+#include "../simd/exponential.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+ template<qualifier Q>
+ struct compute_sqrt<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_sqrt_ps(v.data);
+ return Result;
+ }
+ };
+
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+ template<>
+ struct compute_sqrt<4, float, aligned_lowp, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v)
+ {
+ vec<4, float, aligned_lowp> Result;
+ Result.data = glm_vec4_sqrt_lowp(v.data);
+ return Result;
+ }
+ };
+# endif
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/src/include/glm/detail/func_geometric.inl b/src/include/glm/detail/func_geometric.inl new file mode 100644 index 0000000..7689756 --- /dev/null +++ b/src/include/glm/detail/func_geometric.inl @@ -0,0 +1,243 @@ +#include "../exponential.hpp"
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_length
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& v)
+ {
+ return sqrt(dot(v, v));
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_distance
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+ {
+ return length(p1 - p0);
+ }
+ };
+
+ template<typename V, typename T, bool Aligned>
+ struct compute_dot{};
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_dot<vec<1, T, Q>, T, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b)
+ {
+ return a.x * b.x;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_dot<vec<2, T, Q>, T, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b)
+ {
+ vec<2, T, Q> tmp(a * b);
+ return tmp.x + tmp.y;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_dot<vec<3, T, Q>, T, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b)
+ {
+ vec<3, T, Q> tmp(a * b);
+ return tmp.x + tmp.y + tmp.z;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_dot<vec<4, T, Q>, T, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> tmp(a * b);
+ return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_cross
+ {
+ GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
+
+ return vec<3, T, Q>(
+ x.y * y.z - y.y * x.z,
+ x.z * y.x - y.z * x.x,
+ x.x * y.y - y.x * x.y);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_normalize
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+ return v * inversesqrt(dot(v, v));
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_faceforward
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+ return dot(Nref, I) < static_cast<T>(0) ? N : -N;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_reflect
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+ {
+ return I - N * dot(N, I) * static_cast<T>(2);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_refract
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+ {
+ T const dotValue(dot(N, I));
+ T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+ vec<L, T, Q> const Result =
+ (k >= static_cast<T>(0)) ? (eta * I - (eta * dotValue + std::sqrt(k)) * N) : vec<L, T, Q>(0);
+ return Result;
+ }
+ };
+}//namespace detail
+
+ // length
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType length(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
+
+ return abs(x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER T length(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
+
+ return detail::compute_length<L, T, Q, detail::is_aligned<Q>::value>::call(v);
+ }
+
+ // distance
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
+
+ return length(p1 - p0);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
+ {
+ return detail::compute_distance<L, T, Q, detail::is_aligned<Q>::value>::call(p0, p1);
+ }
+
+ // dot
+ template<typename T>
+ GLM_FUNC_QUALIFIER T dot(T x, T y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+ return x * y;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
+ return detail::compute_dot<vec<L, T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+ }
+
+ // cross
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
+ {
+ return detail::compute_cross<T, Q, detail::is_aligned<Q>::value>::call(x, y);
+ }
+/*
+ // normalize
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType normalize(genType const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+ return x < genType(0) ? genType(-1) : genType(1);
+ }
+*/
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> normalize(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
+
+ return detail::compute_normalize<L, T, Q, detail::is_aligned<Q>::value>::call(x);
+ }
+
+ // faceforward
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref)
+ {
+ return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> faceforward(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
+ {
+ return detail::compute_faceforward<L, T, Q, detail::is_aligned<Q>::value>::call(N, I, Nref);
+ }
+
+ // reflect
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N)
+ {
+ return I - N * dot(N, I) * genType(2);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> reflect(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
+ {
+ return detail::compute_reflect<L, T, Q, detail::is_aligned<Q>::value>::call(I, N);
+ }
+
+ // refract
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
+ genType const dotValue(dot(N, I));
+ genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
+ return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> refract(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
+ return detail::compute_refract<L, T, Q, detail::is_aligned<Q>::value>::call(I, N, eta);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_geometric_simd.inl"
+#endif
diff --git a/src/include/glm/detail/func_geometric_simd.inl b/src/include/glm/detail/func_geometric_simd.inl new file mode 100644 index 0000000..7a8e127 --- /dev/null +++ b/src/include/glm/detail/func_geometric_simd.inl @@ -0,0 +1,163 @@ +/// @ref core
+/// @file glm/detail/func_geometric_simd.inl
+
+#include "../simd/geometric.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+ template<qualifier Q>
+ struct compute_length<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
+ {
+ return _mm_cvtss_f32(glm_vec4_length(v.data));
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_distance<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
+ {
+ return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_dot<vec<4, float, Q>, float, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+ {
+ return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_cross<float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b)
+ {
+ __m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
+ __m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
+ __m128 const xpd0 = glm_vec4_cross(set0, set1);
+
+ vec<4, float, Q> Result;
+ Result.data = xpd0;
+ return vec<3, float, Q>(Result);
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_normalize<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ vec<4, float, Q> Result;
+ Result.data = glm_vec4_normalize(v.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_faceforward<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref)
+ {
+ vec<4, float, Q> Result;
+ Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_reflect<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N)
+ {
+ vec<4, float, Q> Result;
+ Result.data = glm_vec4_reflect(I.data, N.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_refract<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta)
+ {
+ vec<4, float, Q> Result;
+ Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
+ return Result;
+ }
+ };
+}//namespace detail
+}//namespace glm
+
+#elif GLM_ARCH & GLM_ARCH_NEON_BIT
+namespace glm{
+namespace detail
+{
+ template<qualifier Q>
+ struct compute_length<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
+ {
+ return sqrt(compute_dot<vec<4, float, Q>, float, true>::call(v, v));
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_distance<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
+ {
+ return compute_length<4, float, Q, true>::call(p1 - p0);
+ }
+ };
+
+
+ template<qualifier Q>
+ struct compute_dot<vec<4, float, Q>, float, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
+ {
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+ float32x4_t v = vmulq_f32(x.data, y.data);
+ return vaddvq_f32(v);
+#else // Armv7a with Neon
+ float32x4_t p = vmulq_f32(x.data, y.data);
+ float32x2_t v = vpadd_f32(vget_low_f32(p), vget_high_f32(p));
+ v = vpadd_f32(v, v);
+ return vget_lane_f32(v, 0);
+#endif
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_normalize<4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
+ {
+ float32x4_t p = vmulq_f32(v.data, v.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+ p = vpaddq_f32(p, p);
+ p = vpaddq_f32(p, p);
+#else
+ float32x2_t t = vpadd_f32(vget_low_f32(p), vget_high_f32(p));
+ t = vpadd_f32(t, t);
+ p = vcombine_f32(t, t);
+#endif
+
+ float32x4_t vd = vrsqrteq_f32(p);
+ vec<4, float, Q> Result;
+ Result.data = vmulq_f32(v.data, vd);
+ return Result;
+ }
+ };
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/src/include/glm/detail/func_integer.inl b/src/include/glm/detail/func_integer.inl new file mode 100644 index 0000000..f02d6ab --- /dev/null +++ b/src/include/glm/detail/func_integer.inl @@ -0,0 +1,372 @@ +/// @ref core
+
+#include "_vectorize.hpp"
+#if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+# include <intrin.h>
+# pragma intrinsic(_BitScanReverse)
+#endif//(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
+#include <limits>
+
+#if !GLM_HAS_EXTENDED_INTEGER_TYPE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic ignored "-Wlong-long"
+# endif
+# if (GLM_COMPILER & GLM_COMPILER_CLANG)
+# pragma clang diagnostic ignored "-Wc++11-long-long"
+# endif
+#endif
+
+namespace glm{
+namespace detail
+{
+ template<typename T>
+ GLM_FUNC_QUALIFIER T mask(T Bits)
+ {
+ return Bits >= static_cast<T>(sizeof(T) * 8) ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+ }
+
+ template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+ struct compute_bitfieldReverseStep
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+ {
+ return v;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_bitfieldReverseStep<L, T, Q, Aligned, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+ {
+ return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned, bool EXEC>
+ struct compute_bitfieldBitCountStep
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T, T)
+ {
+ return v;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, bool Aligned>
+ struct compute_bitfieldBitCountStep<L, T, Q, Aligned, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Mask, T Shift)
+ {
+ return (v & Mask) + ((v >> Shift) & Mask);
+ }
+ };
+
+ template<typename genIUType, size_t Bits>
+ struct compute_findLSB
+ {
+ GLM_FUNC_QUALIFIER static int call(genIUType Value)
+ {
+ if(Value == 0)
+ return -1;
+
+ return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+ }
+ };
+
+# if GLM_HAS_BITSCAN_WINDOWS
+ template<typename genIUType>
+ struct compute_findLSB<genIUType, 32>
+ {
+ GLM_FUNC_QUALIFIER static int call(genIUType Value)
+ {
+ unsigned long Result(0);
+ unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+ return IsNotNull ? int(Result) : -1;
+ }
+ };
+
+# if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+ template<typename genIUType>
+ struct compute_findLSB<genIUType, 64>
+ {
+ GLM_FUNC_QUALIFIER static int call(genIUType Value)
+ {
+ unsigned long Result(0);
+ unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+ return IsNotNull ? int(Result) : -1;
+ }
+ };
+# endif
+# endif//GLM_HAS_BITSCAN_WINDOWS
+
+ template<length_t L, typename T, qualifier Q, bool EXEC = true>
+ struct compute_findMSB_step_vec
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T Shift)
+ {
+ return x | (x >> Shift);
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q>
+ struct compute_findMSB_step_vec<L, T, Q, false>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, T)
+ {
+ return x;
+ }
+ };
+
+ template<length_t L, typename T, qualifier Q, int>
+ struct compute_findMSB_vec
+ {
+ GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& v)
+ {
+ vec<L, T, Q> x(v);
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 8>::call(x, static_cast<T>( 1));
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 8>::call(x, static_cast<T>( 2));
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 8>::call(x, static_cast<T>( 4));
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+ x = compute_findMSB_step_vec<L, T, Q, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+ return vec<L, int, Q>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+ }
+ };
+
+# if GLM_HAS_BITSCAN_WINDOWS
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+ {
+ unsigned long Result(0);
+ unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+ return IsNotNull ? int(Result) : -1;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ struct compute_findMSB_vec<L, T, Q, 32>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_32, x);
+ }
+ };
+
+# if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+ {
+ unsigned long Result(0);
+ unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+ return IsNotNull ? int(Result) : -1;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ struct compute_findMSB_vec<L, T, Q, 64>
+ {
+ GLM_FUNC_QUALIFIER static vec<L, int, Q> call(vec<L, T, Q> const& x)
+ {
+ return detail::functor1<vec, L, int, T, Q>::call(compute_findMSB_64, x);
+ }
+ };
+# endif
+# endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
+ // uaddCarry
+ GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry)
+ {
+ detail::uint64 const Value64(static_cast<detail::uint64>(x) + static_cast<detail::uint64>(y));
+ detail::uint64 const Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+ Carry = Value64 > Max32 ? 1u : 0u;
+ return static_cast<uint>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, uint, Q> uaddCarry(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Carry)
+ {
+ vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) + vec<L, detail::uint64, Q>(y));
+ vec<L, detail::uint64, Q> Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
+ Carry = mix(vec<L, uint, Q>(0), vec<L, uint, Q>(1), greaterThan(Value64, Max32));
+ return vec<L, uint, Q>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
+ }
+
+ // usubBorrow
+ GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow)
+ {
+ Borrow = x >= y ? static_cast<uint>(0) : static_cast<uint>(1);
+ if(y >= x)
+ return y - x;
+ else
+ return static_cast<uint>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (static_cast<detail::int64>(y) - static_cast<detail::int64>(x)));
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, uint, Q> usubBorrow(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Borrow)
+ {
+ Borrow = mix(vec<L, uint, Q>(1), vec<L, uint, Q>(0), greaterThanEqual(x, y));
+ vec<L, uint, Q> const YgeX(y - x);
+ vec<L, uint, Q> const XgeY(vec<L, uint, Q>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (vec<L, detail::int64, Q>(y) - vec<L, detail::int64, Q>(x))));
+ return mix(XgeY, YgeX, greaterThanEqual(y, x));
+ }
+
+ // umulExtended
+ GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb)
+ {
+ detail::uint64 Value64 = static_cast<detail::uint64>(x) * static_cast<detail::uint64>(y);
+ msb = static_cast<uint>(Value64 >> static_cast<detail::uint64>(32));
+ lsb = static_cast<uint>(Value64);
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER void umulExtended(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& msb, vec<L, uint, Q>& lsb)
+ {
+ vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) * vec<L, detail::uint64, Q>(y));
+ msb = vec<L, uint, Q>(Value64 >> static_cast<detail::uint64>(32));
+ lsb = vec<L, uint, Q>(Value64);
+ }
+
+ // imulExtended
+ GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb)
+ {
+ detail::int64 Value64 = static_cast<detail::int64>(x) * static_cast<detail::int64>(y);
+ msb = static_cast<int>(Value64 >> static_cast<detail::int64>(32));
+ lsb = static_cast<int>(Value64);
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER void imulExtended(vec<L, int, Q> const& x, vec<L, int, Q> const& y, vec<L, int, Q>& msb, vec<L, int, Q>& lsb)
+ {
+ vec<L, detail::int64, Q> Value64(vec<L, detail::int64, Q>(x) * vec<L, detail::int64, Q>(y));
+ lsb = vec<L, int, Q>(Value64 & static_cast<detail::int64>(0xFFFFFFFF));
+ msb = vec<L, int, Q>((Value64 >> static_cast<detail::int64>(32)) & static_cast<detail::int64>(0xFFFFFFFF));
+ }
+
+ // bitfieldExtract
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
+ {
+ return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldExtract(vec<L, T, Q> const& Value, int Offset, int Bits)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
+
+ return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
+ }
+
+ // bitfieldInsert
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+
+ return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldInsert(vec<L, T, Q> const& Base, vec<L, T, Q> const& Insert, int Offset, int Bits)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
+
+ T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
+ return (Base & ~Mask) | ((Insert << static_cast<T>(Offset)) & Mask);
+ }
+
+ // bitfieldReverse
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+ return bitfieldReverse(glm::vec<1, genIUType, glm::defaultp>(x)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldReverse(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldReverse' only accept integer values");
+
+ vec<L, T, Q> x(v);
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 2>::call(x, static_cast<T>(0x5555555555555555ull), static_cast<T>( 1));
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 4>::call(x, static_cast<T>(0x3333333333333333ull), static_cast<T>( 2));
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 8>::call(x, static_cast<T>(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, static_cast<T>(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, static_cast<T>(0x0000FFFF0000FFFFull), static_cast<T>(16));
+ x = detail::compute_bitfieldReverseStep<L, T, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, static_cast<T>(0x00000000FFFFFFFFull), static_cast<T>(32));
+ return x;
+ }
+
+ // bitCount
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER int bitCount(genIUType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+ return bitCount(glm::vec<1, genIUType, glm::defaultp>(x)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, int, Q> bitCount(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
+
+# if GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable : 4310) //cast truncates constant value
+# endif
+
+ vec<L, typename detail::make_unsigned<T>::type, Q> x(*reinterpret_cast<vec<L, typename detail::make_unsigned<T>::type, Q> const *>(&v));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+ x = detail::compute_bitfieldBitCountStep<L, typename detail::make_unsigned<T>::type, Q, detail::is_aligned<Q>::value, sizeof(T) * 8>= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+ return vec<L, int, Q>(x);
+
+# if GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+ }
+
+ // findLSB
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+
+ return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, int, Q> findLSB(vec<L, T, Q> const& x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
+
+ return detail::functor1<vec, L, int, T, Q>::call(findLSB, x);
+ }
+
+ // findMSB
+ template<typename genIUType>
+ GLM_FUNC_QUALIFIER int findMSB(genIUType v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+ return findMSB(vec<1, genIUType>(v)).x;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, int, Q> findMSB(vec<L, T, Q> const& v)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
+
+ return detail::compute_findMSB_vec<L, T, Q, sizeof(T) * 8>::call(v);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_integer_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/func_integer_simd.inl b/src/include/glm/detail/func_integer_simd.inl new file mode 100644 index 0000000..96ed825 --- /dev/null +++ b/src/include/glm/detail/func_integer_simd.inl @@ -0,0 +1,65 @@ +#include "../simd/integer.h"
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+ template<qualifier Q>
+ struct compute_bitfieldReverseStep<4, uint, Q, true, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+ {
+ __m128i const set0 = v.data;
+
+ __m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+ __m128i const and1 = _mm_and_si128(set0, set1);
+ __m128i const sft1 = _mm_slli_epi32(and1, Shift);
+
+ __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1));
+ __m128i const and2 = _mm_and_si128(set0, set2);
+ __m128i const sft2 = _mm_srai_epi32(and2, Shift);
+
+ __m128i const or0 = _mm_or_si128(sft1, sft2);
+
+ return or0;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_bitfieldBitCountStep<4, uint, Q, true, true>
+ {
+ GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v, uint Mask, uint Shift)
+ {
+ __m128i const set0 = v.data;
+
+ __m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
+ __m128i const and0 = _mm_and_si128(set0, set1);
+ __m128i const sft0 = _mm_slli_epi32(set0, Shift);
+ __m128i const and1 = _mm_and_si128(sft0, set1);
+ __m128i const add0 = _mm_add_epi32(and0, and1);
+
+ return add0;
+ }
+ };
+}//namespace detail
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<>
+ GLM_FUNC_QUALIFIER int bitCount(uint x)
+ {
+ return _mm_popcnt_u32(x);
+ }
+
+# if(GLM_MODEL == GLM_MODEL_64)
+ template<>
+ GLM_FUNC_QUALIFIER int bitCount(detail::uint64 x)
+ {
+ return static_cast<int>(_mm_popcnt_u64(x));
+ }
+# endif//GLM_MODEL
+# endif//GLM_ARCH
+
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
diff --git a/src/include/glm/detail/func_matrix.inl b/src/include/glm/detail/func_matrix.inl new file mode 100644 index 0000000..c7063fa --- /dev/null +++ b/src/include/glm/detail/func_matrix.inl @@ -0,0 +1,398 @@ +#include "../geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+ template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+ struct compute_matrixCompMult
+ {
+ GLM_FUNC_QUALIFIER static mat<C, R, T, Q> call(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+ {
+ mat<C, R, T, Q> Result;
+ for(length_t i = 0; i < Result.length(); ++i)
+ Result[i] = x[i] * y[i];
+ return Result;
+ }
+ };
+
+ template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+ struct compute_transpose{};
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<2, 2, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+ {
+ mat<2, 2, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<2, 3, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<3, 2, T, Q> call(mat<2, 3, T, Q> const& m)
+ {
+ mat<3,2, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<2, 4, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 2, T, Q> call(mat<2, 4, T, Q> const& m)
+ {
+ mat<4, 2, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ Result[3][0] = m[0][3];
+ Result[3][1] = m[1][3];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<3, 2, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<2, 3, T, Q> call(mat<3, 2, T, Q> const& m)
+ {
+ mat<2, 3, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<3, 3, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+ {
+ mat<3, 3, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ Result[2][2] = m[2][2];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<3, 4, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 3, T, Q> call(mat<3, 4, T, Q> const& m)
+ {
+ mat<4, 3, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ Result[2][2] = m[2][2];
+ Result[3][0] = m[0][3];
+ Result[3][1] = m[1][3];
+ Result[3][2] = m[2][3];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<4, 2, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<2, 4, T, Q> call(mat<4, 2, T, Q> const& m)
+ {
+ mat<2, 4, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+ Result[0][3] = m[3][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+ Result[1][3] = m[3][1];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<4, 3, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<3, 4, T, Q> call(mat<4, 3, T, Q> const& m)
+ {
+ mat<3, 4, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+ Result[0][3] = m[3][0];
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+ Result[1][3] = m[3][1];
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ Result[2][2] = m[2][2];
+ Result[2][3] = m[3][2];
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_transpose<4, 4, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+ {
+ mat<4, 4, T, Q> Result;
+ Result[0][0] = m[0][0];
+ Result[0][1] = m[1][0];
+ Result[0][2] = m[2][0];
+ Result[0][3] = m[3][0];
+
+ Result[1][0] = m[0][1];
+ Result[1][1] = m[1][1];
+ Result[1][2] = m[2][1];
+ Result[1][3] = m[3][1];
+
+ Result[2][0] = m[0][2];
+ Result[2][1] = m[1][2];
+ Result[2][2] = m[2][2];
+ Result[2][3] = m[3][2];
+
+ Result[3][0] = m[0][3];
+ Result[3][1] = m[1][3];
+ Result[3][2] = m[2][3];
+ Result[3][3] = m[3][3];
+ return Result;
+ }
+ };
+
+ template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+ struct compute_determinant{};
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_determinant<2, 2, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, Q> const& m)
+ {
+ return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_determinant<3, 3, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, Q> const& m)
+ {
+ return
+ + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+ - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+ + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_determinant<4, 4, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, Q> const& m)
+ {
+ 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];
+
+ vec<4, T, Q> DetCof(
+ + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+ - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+ + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+ - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+ return
+ m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
+ m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
+ }
+ };
+
+ template<length_t C, length_t R, typename T, qualifier Q, bool Aligned>
+ struct compute_inverse{};
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_inverse<2, 2, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<2, 2, T, Q> call(mat<2, 2, T, Q> const& m)
+ {
+ T OneOverDeterminant = static_cast<T>(1) / (
+ + m[0][0] * m[1][1]
+ - m[1][0] * m[0][1]);
+
+ mat<2, 2, T, Q> Inverse(
+ + m[1][1] * OneOverDeterminant,
+ - m[0][1] * OneOverDeterminant,
+ - m[1][0] * OneOverDeterminant,
+ + m[0][0] * OneOverDeterminant);
+
+ return Inverse;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_inverse<3, 3, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<3, 3, T, Q> call(mat<3, 3, T, Q> const& m)
+ {
+ T OneOverDeterminant = static_cast<T>(1) / (
+ + m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+ - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+ + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
+
+ mat<3, 3, T, Q> Inverse;
+ Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
+ Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
+ Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
+ Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
+ Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
+ Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
+ Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
+ Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
+ Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
+
+ return Inverse;
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_inverse<4, 4, T, Q, Aligned>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 4, T, Q> call(mat<4, 4, T, Q> const& m)
+ {
+ T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+ T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+ T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+ T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+ T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+ T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+ T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+ T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+ T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+ T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+ T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+ T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+ T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+ T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+ T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+ T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+ T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+ T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+ vec<4, T, Q> Fac0(Coef00, Coef00, Coef02, Coef03);
+ vec<4, T, Q> Fac1(Coef04, Coef04, Coef06, Coef07);
+ vec<4, T, Q> Fac2(Coef08, Coef08, Coef10, Coef11);
+ vec<4, T, Q> Fac3(Coef12, Coef12, Coef14, Coef15);
+ vec<4, T, Q> Fac4(Coef16, Coef16, Coef18, Coef19);
+ vec<4, T, Q> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+ vec<4, T, Q> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+ vec<4, T, Q> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+ vec<4, T, Q> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+ vec<4, T, Q> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+ vec<4, T, Q> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+ vec<4, T, Q> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+ vec<4, T, Q> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+ vec<4, T, Q> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+ vec<4, T, Q> SignA(+1, -1, +1, -1);
+ vec<4, T, Q> SignB(-1, +1, -1, +1);
+ mat<4, 4, T, Q> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
+
+ vec<4, T, Q> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+ vec<4, T, Q> Dot0(m[0] * Row0);
+ T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
+
+ T OneOverDeterminant = static_cast<T>(1) / Dot1;
+
+ return Inverse * OneOverDeterminant;
+ }
+ };
+}//namespace detail
+
+ template<length_t C, length_t R, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<C, R, T, Q> matrixCompMult(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
+ return detail::compute_matrixCompMult<C, R, T, Q, detail::is_aligned<Q>::value>::call(x, y);
+ }
+
+ template<length_t DA, length_t DB, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<DA, DB, T, Q>::type outerProduct(vec<DA, T, Q> const& c, vec<DB, T, Q> const& r)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
+
+ typename detail::outerProduct_trait<DA, DB, T, Q>::type m;
+ for(length_t i = 0; i < m.length(); ++i)
+ m[i] = c * r[i];
+ return m;
+ }
+
+ template<length_t C, length_t R, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<C, R, T, Q>::transpose_type transpose(mat<C, R, T, Q> const& m)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
+ return detail::compute_transpose<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+ }
+
+ template<length_t C, length_t R, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER T determinant(mat<C, R, T, Q> const& m)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
+ return detail::compute_determinant<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+ }
+
+ template<length_t C, length_t R, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<C, R, T, Q> inverse(mat<C, R, T, Q> const& m)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");
+ return detail::compute_inverse<C, R, T, Q, detail::is_aligned<Q>::value>::call(m);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_matrix_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/func_matrix_simd.inl b/src/include/glm/detail/func_matrix_simd.inl new file mode 100644 index 0000000..0a618c2 --- /dev/null +++ b/src/include/glm/detail/func_matrix_simd.inl @@ -0,0 +1,249 @@ +#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#include "type_mat4x4.hpp"
+#include "../geometric.hpp"
+#include "../simd/matrix.h"
+#include <cstring>
+
+namespace glm{
+namespace detail
+{
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+ template<qualifier Q>
+ struct compute_matrixCompMult<4, 4, float, Q, true>
+ {
+ GLM_STATIC_ASSERT(detail::is_aligned<Q>::value, "Specialization requires aligned");
+
+ GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y)
+ {
+ mat<4, 4, float, Q> Result;
+ glm_mat4_matrixCompMult(
+ *static_cast<glm_vec4 const (*)[4]>(&x[0].data),
+ *static_cast<glm_vec4 const (*)[4]>(&y[0].data),
+ *static_cast<glm_vec4(*)[4]>(&Result[0].data));
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_transpose<4, 4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+ {
+ mat<4, 4, float, Q> Result;
+ glm_mat4_transpose(&m[0].data, &Result[0].data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_determinant<4, 4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, Q> const& m)
+ {
+ return _mm_cvtss_f32(glm_mat4_determinant(&m[0].data));
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_inverse<4, 4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+ {
+ mat<4, 4, float, Q> Result;
+ glm_mat4_inverse(&m[0].data, &Result[0].data);
+ return Result;
+ }
+ };
+}//namespace detail
+
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+ template<>
+ GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp>(vec<4, float, aligned_lowp> const& c, vec<4, float, aligned_lowp> const& r)
+ {
+ __m128 NativeResult[4];
+ glm_mat4_outerProduct(c.data, r.data, NativeResult);
+ mat<4, 4, float, aligned_lowp> Result;
+ std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+ return Result;
+ }
+
+ template<>
+ GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump>(vec<4, float, aligned_mediump> const& c, vec<4, float, aligned_mediump> const& r)
+ {
+ __m128 NativeResult[4];
+ glm_mat4_outerProduct(c.data, r.data, NativeResult);
+ mat<4, 4, float, aligned_mediump> Result;
+ std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+ return Result;
+ }
+
+ template<>
+ GLM_FUNC_QUALIFIER mat<4, 4, float, aligned_highp> outerProduct<4, 4, float, aligned_highp>(vec<4, float, aligned_highp> const& c, vec<4, float, aligned_highp> const& r)
+ {
+ __m128 NativeResult[4];
+ glm_mat4_outerProduct(c.data, r.data, NativeResult);
+ mat<4, 4, float, aligned_highp> Result;
+ std::memcpy(&Result[0], &NativeResult[0], sizeof(Result));
+ return Result;
+ }
+# endif
+}//namespace glm
+
+#elif GLM_ARCH & GLM_ARCH_NEON_BIT
+
+namespace glm {
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+ template <qualifier Q>
+ GLM_FUNC_QUALIFIER
+ typename std::enable_if<detail::is_aligned<Q>::value, mat<4, 4, float, Q>>::type
+ operator*(mat<4, 4, float, Q> const & m1, mat<4, 4, float, Q> const & m2)
+ {
+ auto MulRow = [&](int l) {
+ float32x4_t const SrcA = m2[l].data;
+
+ float32x4_t r = neon::mul_lane(m1[0].data, SrcA, 0);
+ r = neon::madd_lane(r, m1[1].data, SrcA, 1);
+ r = neon::madd_lane(r, m1[2].data, SrcA, 2);
+ r = neon::madd_lane(r, m1[3].data, SrcA, 3);
+
+ return r;
+ };
+
+ mat<4, 4, float, aligned_highp> Result;
+ Result[0].data = MulRow(0);
+ Result[1].data = MulRow(1);
+ Result[2].data = MulRow(2);
+ Result[3].data = MulRow(3);
+
+ return Result;
+ }
+#endif // CXX11
+
+ template<qualifier Q>
+ struct detail::compute_inverse<4, 4, float, Q, true>
+ {
+ GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& m)
+ {
+ float32x4_t const& m0 = m[0].data;
+ float32x4_t const& m1 = m[1].data;
+ float32x4_t const& m2 = m[2].data;
+ float32x4_t const& m3 = m[3].data;
+
+ // m[2][2] * m[3][3] - m[3][2] * m[2][3];
+ // m[2][2] * m[3][3] - m[3][2] * m[2][3];
+ // m[1][2] * m[3][3] - m[3][2] * m[1][3];
+ // m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+ float32x4_t Fac0;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+ Fac0 = w0 * w1 - w2 * w3;
+ }
+
+ // m[2][1] * m[3][3] - m[3][1] * m[2][3];
+ // m[2][1] * m[3][3] - m[3][1] * m[2][3];
+ // m[1][1] * m[3][3] - m[3][1] * m[1][3];
+ // m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+ float32x4_t Fac1;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+ Fac1 = w0 * w1 - w2 * w3;
+ }
+
+ // m[2][1] * m[3][2] - m[3][1] * m[2][2];
+ // m[2][1] * m[3][2] - m[3][1] * m[2][2];
+ // m[1][1] * m[3][2] - m[3][1] * m[1][2];
+ // m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+ float32x4_t Fac2;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+ Fac2 = w0 * w1 - w2 * w3;
+ }
+
+ // m[2][0] * m[3][3] - m[3][0] * m[2][3];
+ // m[2][0] * m[3][3] - m[3][0] * m[2][3];
+ // m[1][0] * m[3][3] - m[3][0] * m[1][3];
+ // m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+ float32x4_t Fac3;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 3), 3, m2, 3);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 3), neon::dup_lane(m1, 3));
+ Fac3 = w0 * w1 - w2 * w3;
+ }
+
+ // m[2][0] * m[3][2] - m[3][0] * m[2][2];
+ // m[2][0] * m[3][2] - m[3][0] * m[2][2];
+ // m[1][0] * m[3][2] - m[3][0] * m[1][2];
+ // m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+ float32x4_t Fac4;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 2), 3, m2, 2);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 2), neon::dup_lane(m1, 2));
+ Fac4 = w0 * w1 - w2 * w3;
+ }
+
+ // m[2][0] * m[3][1] - m[3][0] * m[2][1];
+ // m[2][0] * m[3][1] - m[3][0] * m[2][1];
+ // m[1][0] * m[3][1] - m[3][0] * m[1][1];
+ // m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+ float32x4_t Fac5;
+ {
+ float32x4_t w0 = vcombine_f32(neon::dup_lane(m2, 0), neon::dup_lane(m1, 0));
+ float32x4_t w1 = neon::copy_lane(neon::dupq_lane(m3, 1), 3, m2, 1);
+ float32x4_t w2 = neon::copy_lane(neon::dupq_lane(m3, 0), 3, m2, 0);
+ float32x4_t w3 = vcombine_f32(neon::dup_lane(m2, 1), neon::dup_lane(m1, 1));
+ Fac5 = w0 * w1 - w2 * w3;
+ }
+
+ float32x4_t Vec0 = neon::copy_lane(neon::dupq_lane(m0, 0), 0, m1, 0); // (m[1][0], m[0][0], m[0][0], m[0][0]);
+ float32x4_t Vec1 = neon::copy_lane(neon::dupq_lane(m0, 1), 0, m1, 1); // (m[1][1], m[0][1], m[0][1], m[0][1]);
+ float32x4_t Vec2 = neon::copy_lane(neon::dupq_lane(m0, 2), 0, m1, 2); // (m[1][2], m[0][2], m[0][2], m[0][2]);
+ float32x4_t Vec3 = neon::copy_lane(neon::dupq_lane(m0, 3), 0, m1, 3); // (m[1][3], m[0][3], m[0][3], m[0][3]);
+
+ float32x4_t Inv0 = Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2;
+ float32x4_t Inv1 = Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4;
+ float32x4_t Inv2 = Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5;
+ float32x4_t Inv3 = Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5;
+
+ float32x4_t r0 = float32x4_t{-1, +1, -1, +1} * Inv0;
+ float32x4_t r1 = float32x4_t{+1, -1, +1, -1} * Inv1;
+ float32x4_t r2 = float32x4_t{-1, +1, -1, +1} * Inv2;
+ float32x4_t r3 = float32x4_t{+1, -1, +1, -1} * Inv3;
+
+ float32x4_t det = neon::mul_lane(r0, m0, 0);
+ det = neon::madd_lane(det, r1, m0, 1);
+ det = neon::madd_lane(det, r2, m0, 2);
+ det = neon::madd_lane(det, r3, m0, 3);
+
+ float32x4_t rdet = vdupq_n_f32(1 / vgetq_lane_f32(det, 0));
+
+ mat<4, 4, float, Q> r;
+ r[0].data = vmulq_f32(r0, rdet);
+ r[1].data = vmulq_f32(r1, rdet);
+ r[2].data = vmulq_f32(r2, rdet);
+ r[3].data = vmulq_f32(r3, rdet);
+ return r;
+ }
+ };
+}//namespace glm
+#endif
diff --git a/src/include/glm/detail/func_packing.inl b/src/include/glm/detail/func_packing.inl new file mode 100644 index 0000000..6d15054 --- /dev/null +++ b/src/include/glm/detail/func_packing.inl @@ -0,0 +1,189 @@ +/// @ref core
+/// @file glm/detail/func_packing.inl
+
+#include "../common.hpp"
+#include "type_half.hpp"
+
+namespace glm
+{
+ GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const& v)
+ {
+ union
+ {
+ unsigned short in[2];
+ uint out;
+ } u;
+
+ vec<2, unsigned short, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
+
+ u.in[0] = result[0];
+ u.in[1] = result[1];
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
+ {
+ union
+ {
+ uint in;
+ unsigned short out[2];
+ } u;
+
+ u.in = p;
+
+ return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f;
+ }
+
+ GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const& v)
+ {
+ union
+ {
+ signed short in[2];
+ uint out;
+ } u;
+
+ vec<2, short, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 32767.0f));
+
+ u.in[0] = result[0];
+ u.in[1] = result[1];
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
+ {
+ union
+ {
+ uint in;
+ signed short out[2];
+ } u;
+
+ u.in = p;
+
+ return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f);
+ }
+
+ GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const& v)
+ {
+ union
+ {
+ unsigned char in[4];
+ uint out;
+ } u;
+
+ vec<4, unsigned char, defaultp> result(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+
+ u.in[0] = result[0];
+ u.in[1] = result[1];
+ u.in[2] = result[2];
+ u.in[3] = result[3];
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
+ {
+ union
+ {
+ uint in;
+ unsigned char out[4];
+ } u;
+
+ u.in = p;
+
+ return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f;
+ }
+
+ GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const& v)
+ {
+ union
+ {
+ signed char in[4];
+ uint out;
+ } u;
+
+ vec<4, signed char, defaultp> result(round(clamp(v, -1.0f, 1.0f) * 127.0f));
+
+ u.in[0] = result[0];
+ u.in[1] = result[1];
+ u.in[2] = result[2];
+ u.in[3] = result[3];
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
+ {
+ union
+ {
+ uint in;
+ signed char out[4];
+ } u;
+
+ u.in = p;
+
+ return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f);
+ }
+
+ GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const& v)
+ {
+ union
+ {
+ uint in[2];
+ double out;
+ } u;
+
+ u.in[0] = v[0];
+ u.in[1] = v[1];
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
+ {
+ union
+ {
+ double in;
+ uint out[2];
+ } u;
+
+ u.in = v;
+
+ return uvec2(u.out[0], u.out[1]);
+ }
+
+ GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const& v)
+ {
+ union
+ {
+ signed short in[2];
+ uint out;
+ } u;
+
+ u.in[0] = detail::toFloat16(v.x);
+ u.in[1] = detail::toFloat16(v.y);
+
+ return u.out;
+ }
+
+ GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
+ {
+ union
+ {
+ uint in;
+ signed short out[2];
+ } u;
+
+ u.in = v;
+
+ return vec2(
+ detail::toFloat32(u.out[0]),
+ detail::toFloat32(u.out[1]));
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_packing_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/func_packing_simd.inl b/src/include/glm/detail/func_packing_simd.inl new file mode 100644 index 0000000..b8b5a98 --- /dev/null +++ b/src/include/glm/detail/func_packing_simd.inl @@ -0,0 +1,6 @@ +namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/func_trigonometric.inl b/src/include/glm/detail/func_trigonometric.inl new file mode 100644 index 0000000..1b0ad3b --- /dev/null +++ b/src/include/glm/detail/func_trigonometric.inl @@ -0,0 +1,197 @@ +#include "_vectorize.hpp"
+#include <cmath>
+#include <limits>
+
+namespace glm
+{
+ // radians
+ template<typename genType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
+
+ return degrees * static_cast<genType>(0.01745329251994329576923690768489);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> radians(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(radians, v);
+ }
+
+ // degrees
+ template<typename genType>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
+
+ return radians * static_cast<genType>(57.295779513082320876798154814105);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> degrees(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(degrees, v);
+ }
+
+ // sin
+ using ::std::sin;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> sin(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(sin, v);
+ }
+
+ // cos
+ using std::cos;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> cos(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(cos, v);
+ }
+
+ // tan
+ using std::tan;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> tan(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(tan, v);
+ }
+
+ // asin
+ using std::asin;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> asin(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(asin, v);
+ }
+
+ // acos
+ using std::acos;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> acos(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(acos, v);
+ }
+
+ // atan
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
+
+ return ::std::atan2(y, x);
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
+ {
+ return detail::functor2<vec, L, T, Q>::call(::std::atan2, a, b);
+ }
+
+ using std::atan;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(atan, v);
+ }
+
+ // sinh
+ using std::sinh;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> sinh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(sinh, v);
+ }
+
+ // cosh
+ using std::cosh;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> cosh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(cosh, v);
+ }
+
+ // tanh
+ using std::tanh;
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> tanh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(tanh, v);
+ }
+
+ // asinh
+# if GLM_HAS_CXX11_STL
+ using std::asinh;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType asinh(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
+
+ return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x));
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> asinh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(asinh, v);
+ }
+
+ // acosh
+# if GLM_HAS_CXX11_STL
+ using std::acosh;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType acosh(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
+
+ if(x < static_cast<genType>(1))
+ return static_cast<genType>(0);
+ return log(x + sqrt(x * x - static_cast<genType>(1)));
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> acosh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(acosh, v);
+ }
+
+ // atanh
+# if GLM_HAS_CXX11_STL
+ using std::atanh;
+# else
+ template<typename genType>
+ GLM_FUNC_QUALIFIER genType atanh(genType x)
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
+
+ if(std::abs(x) >= static_cast<genType>(1))
+ return 0;
+ return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
+ }
+# endif
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER vec<L, T, Q> atanh(vec<L, T, Q> const& v)
+ {
+ return detail::functor1<vec, L, T, T, Q>::call(atanh, v);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_trigonometric_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/func_trigonometric_simd.inl b/src/include/glm/detail/func_trigonometric_simd.inl new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/include/glm/detail/func_trigonometric_simd.inl diff --git a/src/include/glm/detail/func_vector_relational.inl b/src/include/glm/detail/func_vector_relational.inl new file mode 100644 index 0000000..67653fb --- /dev/null +++ b/src/include/glm/detail/func_vector_relational.inl @@ -0,0 +1,87 @@ +namespace glm
+{
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] < y[i];
+ return Result;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> lessThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] <= y[i];
+ return Result;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThan(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] > y[i];
+ return Result;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> greaterThanEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] >= y[i];
+ return Result;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] == y[i];
+ return Result;
+ }
+
+ template<length_t L, typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = x[i] != y[i];
+ return Result;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool any(vec<L, bool, Q> const& v)
+ {
+ bool Result = false;
+ for(length_t i = 0; i < L; ++i)
+ Result = Result || v[i];
+ return Result;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool all(vec<L, bool, Q> const& v)
+ {
+ bool Result = true;
+ for(length_t i = 0; i < L; ++i)
+ Result = Result && v[i];
+ return Result;
+ }
+
+ template<length_t L, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, bool, Q> not_(vec<L, bool, Q> const& v)
+ {
+ vec<L, bool, Q> Result(true);
+ for(length_t i = 0; i < L; ++i)
+ Result[i] = !v[i];
+ return Result;
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "func_vector_relational_simd.inl"
+#endif
diff --git a/src/include/glm/detail/func_vector_relational_simd.inl b/src/include/glm/detail/func_vector_relational_simd.inl new file mode 100644 index 0000000..b8b5a98 --- /dev/null +++ b/src/include/glm/detail/func_vector_relational_simd.inl @@ -0,0 +1,6 @@ +namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/glm.cpp b/src/include/glm/detail/glm.cpp new file mode 100644 index 0000000..aec632f --- /dev/null +++ b/src/include/glm/detail/glm.cpp @@ -0,0 +1,263 @@ +/// @ref core
+/// @file glm/glm.cpp
+
+#ifndef GLM_ENABLE_EXPERIMENTAL
+#define GLM_ENABLE_EXPERIMENTAL
+#endif
+#include <glm/gtx/dual_quaternion.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <glm/glm.hpp>
+
+namespace glm
+{
+// tvec1 type explicit instantiation
+template struct vec<1, uint8, lowp>;
+template struct vec<1, uint16, lowp>;
+template struct vec<1, uint32, lowp>;
+template struct vec<1, uint64, lowp>;
+template struct vec<1, int8, lowp>;
+template struct vec<1, int16, lowp>;
+template struct vec<1, int32, lowp>;
+template struct vec<1, int64, lowp>;
+template struct vec<1, float32, lowp>;
+template struct vec<1, float64, lowp>;
+
+template struct vec<1, uint8, mediump>;
+template struct vec<1, uint16, mediump>;
+template struct vec<1, uint32, mediump>;
+template struct vec<1, uint64, mediump>;
+template struct vec<1, int8, mediump>;
+template struct vec<1, int16, mediump>;
+template struct vec<1, int32, mediump>;
+template struct vec<1, int64, mediump>;
+template struct vec<1, float32, mediump>;
+template struct vec<1, float64, mediump>;
+
+template struct vec<1, uint8, highp>;
+template struct vec<1, uint16, highp>;
+template struct vec<1, uint32, highp>;
+template struct vec<1, uint64, highp>;
+template struct vec<1, int8, highp>;
+template struct vec<1, int16, highp>;
+template struct vec<1, int32, highp>;
+template struct vec<1, int64, highp>;
+template struct vec<1, float32, highp>;
+template struct vec<1, float64, highp>;
+
+// tvec2 type explicit instantiation
+template struct vec<2, uint8, lowp>;
+template struct vec<2, uint16, lowp>;
+template struct vec<2, uint32, lowp>;
+template struct vec<2, uint64, lowp>;
+template struct vec<2, int8, lowp>;
+template struct vec<2, int16, lowp>;
+template struct vec<2, int32, lowp>;
+template struct vec<2, int64, lowp>;
+template struct vec<2, float32, lowp>;
+template struct vec<2, float64, lowp>;
+
+template struct vec<2, uint8, mediump>;
+template struct vec<2, uint16, mediump>;
+template struct vec<2, uint32, mediump>;
+template struct vec<2, uint64, mediump>;
+template struct vec<2, int8, mediump>;
+template struct vec<2, int16, mediump>;
+template struct vec<2, int32, mediump>;
+template struct vec<2, int64, mediump>;
+template struct vec<2, float32, mediump>;
+template struct vec<2, float64, mediump>;
+
+template struct vec<2, uint8, highp>;
+template struct vec<2, uint16, highp>;
+template struct vec<2, uint32, highp>;
+template struct vec<2, uint64, highp>;
+template struct vec<2, int8, highp>;
+template struct vec<2, int16, highp>;
+template struct vec<2, int32, highp>;
+template struct vec<2, int64, highp>;
+template struct vec<2, float32, highp>;
+template struct vec<2, float64, highp>;
+
+// tvec3 type explicit instantiation
+template struct vec<3, uint8, lowp>;
+template struct vec<3, uint16, lowp>;
+template struct vec<3, uint32, lowp>;
+template struct vec<3, uint64, lowp>;
+template struct vec<3, int8, lowp>;
+template struct vec<3, int16, lowp>;
+template struct vec<3, int32, lowp>;
+template struct vec<3, int64, lowp>;
+template struct vec<3, float32, lowp>;
+template struct vec<3, float64, lowp>;
+
+template struct vec<3, uint8, mediump>;
+template struct vec<3, uint16, mediump>;
+template struct vec<3, uint32, mediump>;
+template struct vec<3, uint64, mediump>;
+template struct vec<3, int8, mediump>;
+template struct vec<3, int16, mediump>;
+template struct vec<3, int32, mediump>;
+template struct vec<3, int64, mediump>;
+template struct vec<3, float32, mediump>;
+template struct vec<3, float64, mediump>;
+
+template struct vec<3, uint8, highp>;
+template struct vec<3, uint16, highp>;
+template struct vec<3, uint32, highp>;
+template struct vec<3, uint64, highp>;
+template struct vec<3, int8, highp>;
+template struct vec<3, int16, highp>;
+template struct vec<3, int32, highp>;
+template struct vec<3, int64, highp>;
+template struct vec<3, float32, highp>;
+template struct vec<3, float64, highp>;
+
+// tvec4 type explicit instantiation
+template struct vec<4, uint8, lowp>;
+template struct vec<4, uint16, lowp>;
+template struct vec<4, uint32, lowp>;
+template struct vec<4, uint64, lowp>;
+template struct vec<4, int8, lowp>;
+template struct vec<4, int16, lowp>;
+template struct vec<4, int32, lowp>;
+template struct vec<4, int64, lowp>;
+template struct vec<4, float32, lowp>;
+template struct vec<4, float64, lowp>;
+
+template struct vec<4, uint8, mediump>;
+template struct vec<4, uint16, mediump>;
+template struct vec<4, uint32, mediump>;
+template struct vec<4, uint64, mediump>;
+template struct vec<4, int8, mediump>;
+template struct vec<4, int16, mediump>;
+template struct vec<4, int32, mediump>;
+template struct vec<4, int64, mediump>;
+template struct vec<4, float32, mediump>;
+template struct vec<4, float64, mediump>;
+
+template struct vec<4, uint8, highp>;
+template struct vec<4, uint16, highp>;
+template struct vec<4, uint32, highp>;
+template struct vec<4, uint64, highp>;
+template struct vec<4, int8, highp>;
+template struct vec<4, int16, highp>;
+template struct vec<4, int32, highp>;
+template struct vec<4, int64, highp>;
+template struct vec<4, float32, highp>;
+template struct vec<4, float64, highp>;
+
+// tmat2x2 type explicit instantiation
+template struct mat<2, 2, float32, lowp>;
+template struct mat<2, 2, float64, lowp>;
+
+template struct mat<2, 2, float32, mediump>;
+template struct mat<2, 2, float64, mediump>;
+
+template struct mat<2, 2, float32, highp>;
+template struct mat<2, 2, float64, highp>;
+
+// tmat2x3 type explicit instantiation
+template struct mat<2, 3, float32, lowp>;
+template struct mat<2, 3, float64, lowp>;
+
+template struct mat<2, 3, float32, mediump>;
+template struct mat<2, 3, float64, mediump>;
+
+template struct mat<2, 3, float32, highp>;
+template struct mat<2, 3, float64, highp>;
+
+// tmat2x4 type explicit instantiation
+template struct mat<2, 4, float32, lowp>;
+template struct mat<2, 4, float64, lowp>;
+
+template struct mat<2, 4, float32, mediump>;
+template struct mat<2, 4, float64, mediump>;
+
+template struct mat<2, 4, float32, highp>;
+template struct mat<2, 4, float64, highp>;
+
+// tmat3x2 type explicit instantiation
+template struct mat<3, 2, float32, lowp>;
+template struct mat<3, 2, float64, lowp>;
+
+template struct mat<3, 2, float32, mediump>;
+template struct mat<3, 2, float64, mediump>;
+
+template struct mat<3, 2, float32, highp>;
+template struct mat<3, 2, float64, highp>;
+
+// tmat3x3 type explicit instantiation
+template struct mat<3, 3, float32, lowp>;
+template struct mat<3, 3, float64, lowp>;
+
+template struct mat<3, 3, float32, mediump>;
+template struct mat<3, 3, float64, mediump>;
+
+template struct mat<3, 3, float32, highp>;
+template struct mat<3, 3, float64, highp>;
+
+// tmat3x4 type explicit instantiation
+template struct mat<3, 4, float32, lowp>;
+template struct mat<3, 4, float64, lowp>;
+
+template struct mat<3, 4, float32, mediump>;
+template struct mat<3, 4, float64, mediump>;
+
+template struct mat<3, 4, float32, highp>;
+template struct mat<3, 4, float64, highp>;
+
+// tmat4x2 type explicit instantiation
+template struct mat<4, 2, float32, lowp>;
+template struct mat<4, 2, float64, lowp>;
+
+template struct mat<4, 2, float32, mediump>;
+template struct mat<4, 2, float64, mediump>;
+
+template struct mat<4, 2, float32, highp>;
+template struct mat<4, 2, float64, highp>;
+
+// tmat4x3 type explicit instantiation
+template struct mat<4, 3, float32, lowp>;
+template struct mat<4, 3, float64, lowp>;
+
+template struct mat<4, 3, float32, mediump>;
+template struct mat<4, 3, float64, mediump>;
+
+template struct mat<4, 3, float32, highp>;
+template struct mat<4, 3, float64, highp>;
+
+// tmat4x4 type explicit instantiation
+template struct mat<4, 4, float32, lowp>;
+template struct mat<4, 4, float64, lowp>;
+
+template struct mat<4, 4, float32, mediump>;
+template struct mat<4, 4, float64, mediump>;
+
+template struct mat<4, 4, float32, highp>;
+template struct mat<4, 4, float64, highp>;
+
+// tquat type explicit instantiation
+template struct qua<float32, lowp>;
+template struct qua<float64, lowp>;
+
+template struct qua<float32, mediump>;
+template struct qua<float64, mediump>;
+
+template struct qua<float32, highp>;
+template struct qua<float64, highp>;
+
+//tdualquat type explicit instantiation
+template struct tdualquat<float32, lowp>;
+template struct tdualquat<float64, lowp>;
+
+template struct tdualquat<float32, mediump>;
+template struct tdualquat<float64, mediump>;
+
+template struct tdualquat<float32, highp>;
+template struct tdualquat<float64, highp>;
+
+}//namespace glm
+
diff --git a/src/include/glm/detail/qualifier.hpp b/src/include/glm/detail/qualifier.hpp new file mode 100644 index 0000000..5336db6 --- /dev/null +++ b/src/include/glm/detail/qualifier.hpp @@ -0,0 +1,230 @@ +#pragma once
+
+#include "setup.hpp"
+
+namespace glm
+{
+ /// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp)
+ enum qualifier
+ {
+ packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs
+ packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance
+ packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance
+
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+ aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs
+ aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance
+ aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
+ aligned = aligned_highp, ///< By default aligned qualifier is also high precision
+# endif
+
+ highp = packed_highp, ///< By default highp qualifier is also packed
+ mediump = packed_mediump, ///< By default mediump qualifier is also packed
+ lowp = packed_lowp, ///< By default lowp qualifier is also packed
+ packed = packed_highp, ///< By default packed qualifier is also high precision
+
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
+ defaultp = aligned_highp
+# else
+ defaultp = highp
+# endif
+ };
+
+ typedef qualifier precision;
+
+ template<length_t L, typename T, qualifier Q = defaultp> struct vec;
+ template<length_t C, length_t R, typename T, qualifier Q = defaultp> struct mat;
+ template<typename T, qualifier Q = defaultp> struct qua;
+
+# if GLM_HAS_TEMPLATE_ALIASES
+ template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
+ template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
+# endif
+
+namespace detail
+{
+ template<glm::qualifier P>
+ struct is_aligned
+ {
+ static const bool value = false;
+ };
+
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+ template<>
+ struct is_aligned<glm::aligned_lowp>
+ {
+ static const bool value = true;
+ };
+
+ template<>
+ struct is_aligned<glm::aligned_mediump>
+ {
+ static const bool value = true;
+ };
+
+ template<>
+ struct is_aligned<glm::aligned_highp>
+ {
+ static const bool value = true;
+ };
+# endif
+
+ template<length_t L, typename T, bool is_aligned>
+ struct storage
+ {
+ typedef struct type {
+ T data[L];
+ } type;
+ };
+
+# if GLM_HAS_ALIGNOF
+ template<length_t L, typename T>
+ struct storage<L, T, true>
+ {
+ typedef struct alignas(L * sizeof(T)) type {
+ T data[L];
+ } type;
+ };
+
+ template<typename T>
+ struct storage<3, T, true>
+ {
+ typedef struct alignas(4 * sizeof(T)) type {
+ T data[4];
+ } type;
+ };
+# endif
+
+# if GLM_ARCH & GLM_ARCH_SSE2_BIT
+ template<>
+ struct storage<4, float, true>
+ {
+ typedef glm_f32vec4 type;
+ };
+
+ template<>
+ struct storage<4, int, true>
+ {
+ typedef glm_i32vec4 type;
+ };
+
+ template<>
+ struct storage<4, unsigned int, true>
+ {
+ typedef glm_u32vec4 type;
+ };
+
+ template<>
+ struct storage<2, double, true>
+ {
+ typedef glm_f64vec2 type;
+ };
+
+ template<>
+ struct storage<2, detail::int64, true>
+ {
+ typedef glm_i64vec2 type;
+ };
+
+ template<>
+ struct storage<2, detail::uint64, true>
+ {
+ typedef glm_u64vec2 type;
+ };
+# endif
+
+# if (GLM_ARCH & GLM_ARCH_AVX_BIT)
+ template<>
+ struct storage<4, double, true>
+ {
+ typedef glm_f64vec4 type;
+ };
+# endif
+
+# if (GLM_ARCH & GLM_ARCH_AVX2_BIT)
+ template<>
+ struct storage<4, detail::int64, true>
+ {
+ typedef glm_i64vec4 type;
+ };
+
+ template<>
+ struct storage<4, detail::uint64, true>
+ {
+ typedef glm_u64vec4 type;
+ };
+# endif
+
+# if GLM_ARCH & GLM_ARCH_NEON_BIT
+ template<>
+ struct storage<4, float, true>
+ {
+ typedef glm_f32vec4 type;
+ };
+
+ template<>
+ struct storage<4, int, true>
+ {
+ typedef glm_i32vec4 type;
+ };
+
+ template<>
+ struct storage<4, unsigned int, true>
+ {
+ typedef glm_u32vec4 type;
+ };
+# endif
+
+ enum genTypeEnum
+ {
+ GENTYPE_VEC,
+ GENTYPE_MAT,
+ GENTYPE_QUAT
+ };
+
+ template <typename genType>
+ struct genTypeTrait
+ {};
+
+ template <length_t C, length_t R, typename T>
+ struct genTypeTrait<mat<C, R, T> >
+ {
+ static const genTypeEnum GENTYPE = GENTYPE_MAT;
+ };
+
+ template<typename genType, genTypeEnum type>
+ struct init_gentype
+ {
+ };
+
+ template<typename genType>
+ struct init_gentype<genType, GENTYPE_QUAT>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+ {
+ return genType(1, 0, 0, 0);
+ }
+ };
+
+ template<typename genType>
+ struct init_gentype<genType, GENTYPE_MAT>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
+ {
+ return genType(1);
+ }
+ };
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/setup.hpp b/src/include/glm/detail/setup.hpp new file mode 100644 index 0000000..e79f565 --- /dev/null +++ b/src/include/glm/detail/setup.hpp @@ -0,0 +1,1135 @@ +#ifndef GLM_SETUP_INCLUDED
+
+#include <cassert>
+#include <cstddef>
+
+#define GLM_VERSION_MAJOR 0
+#define GLM_VERSION_MINOR 9
+#define GLM_VERSION_PATCH 9
+#define GLM_VERSION_REVISION 8
+#define GLM_VERSION 998
+#define GLM_VERSION_MESSAGE "GLM: version 0.9.9.8"
+
+#define GLM_SETUP_INCLUDED GLM_VERSION
+
+///////////////////////////////////////////////////////////////////////////////////
+// Active states
+
+#define GLM_DISABLE 0
+#define GLM_ENABLE 1
+
+///////////////////////////////////////////////////////////////////////////////////
+// Messages
+
+#if defined(GLM_FORCE_MESSAGES)
+# define GLM_MESSAGES GLM_ENABLE
+#else
+# define GLM_MESSAGES GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Detect the platform
+
+#include "../simd/platform.h"
+
+///////////////////////////////////////////////////////////////////////////////////
+// Build model
+
+#if defined(_M_ARM64) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
+# define GLM_MODEL GLM_MODEL_64
+#elif defined(__i386__) || defined(__ppc__) || defined(__ILP32__) || defined(_M_ARM)
+# define GLM_MODEL GLM_MODEL_32
+#else
+# define GLM_MODEL GLM_MODEL_32
+#endif//
+
+#if !defined(GLM_MODEL) && GLM_COMPILER != 0
+# error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
+#endif//GLM_MODEL
+
+///////////////////////////////////////////////////////////////////////////////////
+// C++ Version
+
+// User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14, GLM_FORCE_CXX17, GLM_FORCE_CXX2A
+
+#define GLM_LANG_CXX98_FLAG (1 << 1)
+#define GLM_LANG_CXX03_FLAG (1 << 2)
+#define GLM_LANG_CXX0X_FLAG (1 << 3)
+#define GLM_LANG_CXX11_FLAG (1 << 4)
+#define GLM_LANG_CXX14_FLAG (1 << 5)
+#define GLM_LANG_CXX17_FLAG (1 << 6)
+#define GLM_LANG_CXX2A_FLAG (1 << 7)
+#define GLM_LANG_CXXMS_FLAG (1 << 8)
+#define GLM_LANG_CXXGNU_FLAG (1 << 9)
+
+#define GLM_LANG_CXX98 GLM_LANG_CXX98_FLAG
+#define GLM_LANG_CXX03 (GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
+#define GLM_LANG_CXX0X (GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
+#define GLM_LANG_CXX11 (GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
+#define GLM_LANG_CXX14 (GLM_LANG_CXX11 | GLM_LANG_CXX14_FLAG)
+#define GLM_LANG_CXX17 (GLM_LANG_CXX14 | GLM_LANG_CXX17_FLAG)
+#define GLM_LANG_CXX2A (GLM_LANG_CXX17 | GLM_LANG_CXX2A_FLAG)
+#define GLM_LANG_CXXMS GLM_LANG_CXXMS_FLAG
+#define GLM_LANG_CXXGNU GLM_LANG_CXXGNU_FLAG
+
+#if (defined(_MSC_EXTENSIONS))
+# define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG
+#elif ((GLM_COMPILER & (GLM_COMPILER_CLANG | GLM_COMPILER_GCC)) && (GLM_ARCH & GLM_ARCH_SIMD_BIT))
+# define GLM_LANG_EXT GLM_LANG_CXXMS_FLAG
+#else
+# define GLM_LANG_EXT 0
+#endif
+
+#if (defined(GLM_FORCE_CXX_UNKNOWN))
+# define GLM_LANG 0
+#elif defined(GLM_FORCE_CXX2A)
+# define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT)
+# define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX17)
+# define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
+# define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX14)
+# define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
+# define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX11)
+# define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
+# define GLM_LANG_STL11_FORCED
+#elif defined(GLM_FORCE_CXX03)
+# define GLM_LANG (GLM_LANG_CXX03 | GLM_LANG_EXT)
+#elif defined(GLM_FORCE_CXX98)
+# define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
+#else
+# if GLM_COMPILER & GLM_COMPILER_VC && defined(_MSVC_LANG)
+# if GLM_COMPILER >= GLM_COMPILER_VC15_7
+# define GLM_LANG_PLATFORM _MSVC_LANG
+# elif GLM_COMPILER >= GLM_COMPILER_VC15
+# if _MSVC_LANG > 201402L
+# define GLM_LANG_PLATFORM 201402L
+# else
+# define GLM_LANG_PLATFORM _MSVC_LANG
+# endif
+# else
+# define GLM_LANG_PLATFORM 0
+# endif
+# else
+# define GLM_LANG_PLATFORM 0
+# endif
+
+# if __cplusplus > 201703L || GLM_LANG_PLATFORM > 201703L
+# define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT)
+# elif __cplusplus == 201703L || GLM_LANG_PLATFORM == 201703L
+# define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
+# elif __cplusplus == 201402L || __cplusplus == 201500L || GLM_LANG_PLATFORM == 201402L
+# define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
+# elif __cplusplus == 201103L || GLM_LANG_PLATFORM == 201103L
+# define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
+# elif defined(__INTEL_CXX11_MODE__) || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+# define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_EXT)
+# elif __cplusplus == 199711L
+# define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
+# else
+# define GLM_LANG (0 | GLM_LANG_EXT)
+# endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Has of C++ features
+
+// http://clang.llvm.org/cxx_status.html
+// http://gcc.gnu.org/projects/cxx0x.html
+// http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
+
+// Android has multiple STLs but C++11 STL detection doesn't always work #284 #564
+#if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED)
+# define GLM_HAS_CXX11_STL 0
+#elif GLM_COMPILER & GLM_COMPILER_CLANG
+# if (defined(_LIBCPP_VERSION) || (GLM_LANG & GLM_LANG_CXX11_FLAG) || defined(GLM_LANG_STL11_FORCED))
+# define GLM_HAS_CXX11_STL 1
+# else
+# define GLM_HAS_CXX11_STL 0
+# endif
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_CXX11_STL 1
+#else
+# define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+ ((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15))))
+#endif
+
+// N1720
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_STATIC_ASSERT 1
+#else
+# define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC))))
+#endif
+
+// N1988
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_EXTENDED_INTEGER_TYPE 1
+#else
+# define GLM_HAS_EXTENDED_INTEGER_TYPE (\
+ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC)) || \
+ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \
+ ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG)))
+#endif
+
+// N2672 Initializer lists http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_INITIALIZER_LISTS 1
+#else
+# define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
+ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_UNRESTRICTED_UNIONS 1
+#else
+# define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ (GLM_COMPILER & GLM_COMPILER_VC) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA)))
+#endif
+
+// N2346
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_DEFAULTED_FUNCTIONS 1
+#else
+# define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+ (GLM_COMPILER & GLM_COMPILER_CUDA)))
+#endif
+
+// N2118
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_RVALUE_REFERENCES 1
+#else
+# define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_VC)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
+#else
+# define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_TEMPLATE_ALIASES 1
+#else
+# define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_RANGE_FOR 1
+#else
+# define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+#if GLM_COMPILER & GLM_COMPILER_CLANG
+# define GLM_HAS_ALIGNOF __has_feature(cxx_alignas)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_ALIGNOF 1
+#else
+# define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+// N2235 Generalized Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+// N3652 Extended Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html
+#if (GLM_ARCH & GLM_ARCH_SIMD_BIT) // Compiler SIMD intrinsics don't support constexpr...
+# define GLM_HAS_CONSTEXPR 0
+#elif (GLM_COMPILER & GLM_COMPILER_CLANG)
+# define GLM_HAS_CONSTEXPR __has_feature(cxx_relaxed_constexpr)
+#elif (GLM_LANG & GLM_LANG_CXX14_FLAG)
+# define GLM_HAS_CONSTEXPR 1
+#else
+# define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && GLM_HAS_INITIALIZER_LISTS && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL17)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15))))
+#endif
+
+#if GLM_HAS_CONSTEXPR
+# define GLM_CONSTEXPR constexpr
+#else
+# define GLM_CONSTEXPR
+#endif
+
+//
+#if GLM_HAS_CONSTEXPR
+# if (GLM_COMPILER & GLM_COMPILER_CLANG)
+# if __has_feature(cxx_if_constexpr)
+# define GLM_HAS_IF_CONSTEXPR 1
+# else
+# define GLM_HAS_IF_CONSTEXPR 0
+# endif
+# elif (GLM_LANG & GLM_LANG_CXX17_FLAG)
+# define GLM_HAS_IF_CONSTEXPR 1
+# else
+# define GLM_HAS_IF_CONSTEXPR 0
+# endif
+#else
+# define GLM_HAS_IF_CONSTEXPR 0
+#endif
+
+#if GLM_HAS_IF_CONSTEXPR
+# define GLM_IF_CONSTEXPR if constexpr
+#else
+# define GLM_IF_CONSTEXPR if
+#endif
+
+//
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_ASSIGNABLE 1
+#else
+# define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
+ ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49))))
+#endif
+
+//
+#define GLM_HAS_TRIVIAL_QUERIES 0
+
+//
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+# define GLM_HAS_MAKE_SIGNED 1
+#else
+# define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
+ ((GLM_COMPILER & GLM_COMPILER_CUDA))))
+#endif
+
+//
+#if defined(GLM_FORCE_INTRINSICS)
+# define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
+ ((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
+ ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT))))
+#else
+# define GLM_HAS_BITSCAN_WINDOWS 0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// OpenMP
+#ifdef _OPENMP
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# if GLM_COMPILER >= GLM_COMPILER_GCC61
+# define GLM_HAS_OPENMP 45
+# elif GLM_COMPILER >= GLM_COMPILER_GCC49
+# define GLM_HAS_OPENMP 40
+# elif GLM_COMPILER >= GLM_COMPILER_GCC47
+# define GLM_HAS_OPENMP 31
+# else
+# define GLM_HAS_OPENMP 0
+# endif
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# if GLM_COMPILER >= GLM_COMPILER_CLANG38
+# define GLM_HAS_OPENMP 31
+# else
+# define GLM_HAS_OPENMP 0
+# endif
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# define GLM_HAS_OPENMP 20
+# elif GLM_COMPILER & GLM_COMPILER_INTEL
+# if GLM_COMPILER >= GLM_COMPILER_INTEL16
+# define GLM_HAS_OPENMP 40
+# else
+# define GLM_HAS_OPENMP 0
+# endif
+# else
+# define GLM_HAS_OPENMP 0
+# endif
+#else
+# define GLM_HAS_OPENMP 0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// nullptr
+
+#if GLM_LANG & GLM_LANG_CXX0X_FLAG
+# define GLM_CONFIG_NULLPTR GLM_ENABLE
+#else
+# define GLM_CONFIG_NULLPTR GLM_DISABLE
+#endif
+
+#if GLM_CONFIG_NULLPTR == GLM_ENABLE
+# define GLM_NULLPTR nullptr
+#else
+# define GLM_NULLPTR 0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Static assert
+
+#if GLM_HAS_STATIC_ASSERT
+# define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+#elif GLM_COMPILER & GLM_COMPILER_VC
+# define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+#else
+# define GLM_STATIC_ASSERT(x, message) assert(x)
+#endif//GLM_LANG
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+# define GLM_CUDA_FUNC_DEF __device__ __host__
+# define GLM_CUDA_FUNC_DECL __device__ __host__
+#else
+# define GLM_CUDA_FUNC_DEF
+# define GLM_CUDA_FUNC_DECL
+#endif
+
+#if defined(GLM_FORCE_INLINE)
+# if GLM_COMPILER & GLM_COMPILER_VC
+# define GLM_INLINE __forceinline
+# define GLM_NEVER_INLINE __declspec((noinline))
+# elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
+# define GLM_INLINE inline __attribute__((__always_inline__))
+# define GLM_NEVER_INLINE __attribute__((__noinline__))
+# elif GLM_COMPILER & GLM_COMPILER_CUDA
+# define GLM_INLINE __forceinline__
+# define GLM_NEVER_INLINE __noinline__
+# else
+# define GLM_INLINE inline
+# define GLM_NEVER_INLINE
+# endif//GLM_COMPILER
+#else
+# define GLM_INLINE inline
+# define GLM_NEVER_INLINE
+#endif//defined(GLM_FORCE_INLINE)
+
+#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Swizzle operators
+
+// User defines: GLM_FORCE_SWIZZLE
+
+#define GLM_SWIZZLE_DISABLED 0
+#define GLM_SWIZZLE_OPERATOR 1
+#define GLM_SWIZZLE_FUNCTION 2
+
+#if defined(GLM_FORCE_XYZW_ONLY)
+# undef GLM_FORCE_SWIZZLE
+#endif
+
+#if defined(GLM_SWIZZLE)
+# pragma message("GLM: GLM_SWIZZLE is deprecated, use GLM_FORCE_SWIZZLE instead.")
+# define GLM_FORCE_SWIZZLE
+#endif
+
+#if defined(GLM_FORCE_SWIZZLE) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)
+# define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_OPERATOR
+#elif defined(GLM_FORCE_SWIZZLE)
+# define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_FUNCTION
+#else
+# define GLM_CONFIG_SWIZZLE GLM_SWIZZLE_DISABLED
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Allows using not basic types as genType
+
+// #define GLM_FORCE_UNRESTRICTED_GENTYPE
+
+#ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
+# define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_ENABLE
+#else
+# define GLM_CONFIG_UNRESTRICTED_GENTYPE GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Clip control, define GLM_FORCE_DEPTH_ZERO_TO_ONE before including GLM
+// to use a clip space between 0 to 1.
+// Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
+// to use left handed coordinate system by default.
+
+#define GLM_CLIP_CONTROL_ZO_BIT (1 << 0) // ZERO_TO_ONE
+#define GLM_CLIP_CONTROL_NO_BIT (1 << 1) // NEGATIVE_ONE_TO_ONE
+#define GLM_CLIP_CONTROL_LH_BIT (1 << 2) // LEFT_HANDED, For DirectX, Metal, Vulkan
+#define GLM_CLIP_CONTROL_RH_BIT (1 << 3) // RIGHT_HANDED, For OpenGL, default in GLM
+
+#define GLM_CLIP_CONTROL_LH_ZO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_ZO_BIT)
+#define GLM_CLIP_CONTROL_LH_NO (GLM_CLIP_CONTROL_LH_BIT | GLM_CLIP_CONTROL_NO_BIT)
+#define GLM_CLIP_CONTROL_RH_ZO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_ZO_BIT)
+#define GLM_CLIP_CONTROL_RH_NO (GLM_CLIP_CONTROL_RH_BIT | GLM_CLIP_CONTROL_NO_BIT)
+
+#ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE
+# ifdef GLM_FORCE_LEFT_HANDED
+# define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_ZO
+# else
+# define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_ZO
+# endif
+#else
+# ifdef GLM_FORCE_LEFT_HANDED
+# define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_LH_NO
+# else
+# define GLM_CONFIG_CLIP_CONTROL GLM_CLIP_CONTROL_RH_NO
+# endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
+# define GLM_DEPRECATED __declspec(deprecated)
+# define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
+#elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL)
+# define GLM_DEPRECATED __attribute__((__deprecated__))
+# define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
+#elif GLM_COMPILER & GLM_COMPILER_CUDA
+# define GLM_DEPRECATED
+# define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x)
+#else
+# define GLM_DEPRECATED
+# define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifdef GLM_FORCE_EXPLICIT_CTOR
+# define GLM_EXPLICIT explicit
+#else
+# define GLM_EXPLICIT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// SYCL
+
+#if GLM_COMPILER==GLM_COMPILER_SYCL
+
+#include <CL/sycl.hpp>
+#include <limits>
+
+namespace glm {
+namespace std {
+ // Import SYCL's functions into the namespace glm::std to force their usages.
+ // It's important to use the math built-in function (sin, exp, ...)
+ // of SYCL instead the std ones.
+ using namespace cl::sycl;
+
+ ///////////////////////////////////////////////////////////////////////////////
+ // Import some "harmless" std's stuffs used by glm into
+ // the new glm::std namespace.
+ template<typename T>
+ using numeric_limits = ::std::numeric_limits<T>;
+
+ using ::std::size_t;
+
+ using ::std::uint8_t;
+ using ::std::uint16_t;
+ using ::std::uint32_t;
+ using ::std::uint64_t;
+
+ using ::std::int8_t;
+ using ::std::int16_t;
+ using ::std::int32_t;
+ using ::std::int64_t;
+
+ using ::std::make_unsigned;
+ ///////////////////////////////////////////////////////////////////////////////
+} //namespace std
+} //namespace glm
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////
+// Length type: all length functions returns a length_t type.
+// When GLM_FORCE_SIZE_T_LENGTH is defined, length_t is a typedef of size_t otherwise
+// length_t is a typedef of int like GLSL defines it.
+
+#define GLM_LENGTH_INT 1
+#define GLM_LENGTH_SIZE_T 2
+
+#ifdef GLM_FORCE_SIZE_T_LENGTH
+# define GLM_CONFIG_LENGTH_TYPE GLM_LENGTH_SIZE_T
+#else
+# define GLM_CONFIG_LENGTH_TYPE GLM_LENGTH_INT
+#endif
+
+namespace glm
+{
+ using std::size_t;
+# if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T
+ typedef size_t length_t;
+# else
+ typedef int length_t;
+# endif
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// constexpr
+
+#if GLM_HAS_CONSTEXPR
+# define GLM_CONFIG_CONSTEXP GLM_ENABLE
+
+ namespace glm
+ {
+ template<typename T, std::size_t N>
+ constexpr std::size_t countof(T const (&)[N])
+ {
+ return N;
+ }
+ }//namespace glm
+# define GLM_COUNTOF(arr) glm::countof(arr)
+#elif defined(_MSC_VER)
+# define GLM_CONFIG_CONSTEXP GLM_DISABLE
+
+# define GLM_COUNTOF(arr) _countof(arr)
+#else
+# define GLM_CONFIG_CONSTEXP GLM_DISABLE
+
+# define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// uint
+
+namespace glm{
+namespace detail
+{
+ template<typename T>
+ struct is_int
+ {
+ enum test {value = 0};
+ };
+
+ template<>
+ struct is_int<unsigned int>
+ {
+ enum test {value = ~0};
+ };
+
+ template<>
+ struct is_int<signed int>
+ {
+ enum test {value = ~0};
+ };
+}//namespace detail
+
+ typedef unsigned int uint;
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// 64-bit int
+
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+# include <cstdint>
+#endif
+
+namespace glm{
+namespace detail
+{
+# if GLM_HAS_EXTENDED_INTEGER_TYPE
+ typedef std::uint64_t uint64;
+ typedef std::int64_t int64;
+# elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
+ typedef uint64_t uint64;
+ typedef int64_t int64;
+# elif GLM_COMPILER & GLM_COMPILER_VC
+ typedef unsigned __int64 uint64;
+ typedef signed __int64 int64;
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic ignored "-Wlong-long"
+ __extension__ typedef unsigned long long uint64;
+ __extension__ typedef signed long long int64;
+# elif (GLM_COMPILER & GLM_COMPILER_CLANG)
+# pragma clang diagnostic ignored "-Wc++11-long-long"
+ typedef unsigned long long uint64;
+ typedef signed long long int64;
+# else//unknown compiler
+ typedef unsigned long long uint64;
+ typedef signed long long int64;
+# endif
+}//namespace detail
+}//namespace glm
+
+///////////////////////////////////////////////////////////////////////////////////
+// make_unsigned
+
+#if GLM_HAS_MAKE_SIGNED
+# include <type_traits>
+
+namespace glm{
+namespace detail
+{
+ using std::make_unsigned;
+}//namespace detail
+}//namespace glm
+
+#else
+
+namespace glm{
+namespace detail
+{
+ template<typename genType>
+ struct make_unsigned
+ {};
+
+ template<>
+ struct make_unsigned<char>
+ {
+ typedef unsigned char type;
+ };
+
+ template<>
+ struct make_unsigned<signed char>
+ {
+ typedef unsigned char type;
+ };
+
+ template<>
+ struct make_unsigned<short>
+ {
+ typedef unsigned short type;
+ };
+
+ template<>
+ struct make_unsigned<int>
+ {
+ typedef unsigned int type;
+ };
+
+ template<>
+ struct make_unsigned<long>
+ {
+ typedef unsigned long type;
+ };
+
+ template<>
+ struct make_unsigned<int64>
+ {
+ typedef uint64 type;
+ };
+
+ template<>
+ struct make_unsigned<unsigned char>
+ {
+ typedef unsigned char type;
+ };
+
+ template<>
+ struct make_unsigned<unsigned short>
+ {
+ typedef unsigned short type;
+ };
+
+ template<>
+ struct make_unsigned<unsigned int>
+ {
+ typedef unsigned int type;
+ };
+
+ template<>
+ struct make_unsigned<unsigned long>
+ {
+ typedef unsigned long type;
+ };
+
+ template<>
+ struct make_unsigned<uint64>
+ {
+ typedef uint64 type;
+ };
+}//namespace detail
+}//namespace glm
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Only use x, y, z, w as vector type components
+
+#ifdef GLM_FORCE_XYZW_ONLY
+# define GLM_CONFIG_XYZW_ONLY GLM_ENABLE
+#else
+# define GLM_CONFIG_XYZW_ONLY GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of defaulted initialized types
+
+#define GLM_CTOR_INIT_DISABLE 0
+#define GLM_CTOR_INITIALIZER_LIST 1
+#define GLM_CTOR_INITIALISATION 2
+
+#if defined(GLM_FORCE_CTOR_INIT) && GLM_HAS_INITIALIZER_LISTS
+# define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALIZER_LIST
+#elif defined(GLM_FORCE_CTOR_INIT) && !GLM_HAS_INITIALIZER_LISTS
+# define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALISATION
+#else
+# define GLM_CONFIG_CTOR_INIT GLM_CTOR_INIT_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Use SIMD instruction sets
+
+#if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_ARCH & GLM_ARCH_SIMD_BIT)
+# define GLM_CONFIG_SIMD GLM_ENABLE
+#else
+# define GLM_CONFIG_SIMD GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of defaulted function
+
+#if GLM_HAS_DEFAULTED_FUNCTIONS && GLM_CONFIG_CTOR_INIT == GLM_CTOR_INIT_DISABLE
+# define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_ENABLE
+# define GLM_DEFAULT = default
+#else
+# define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_DISABLE
+# define GLM_DEFAULT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of aligned gentypes
+
+#ifdef GLM_FORCE_ALIGNED // Legacy define
+# define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#endif
+
+#ifdef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+# define GLM_FORCE_ALIGNED_GENTYPES
+#endif
+
+#if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (defined(GLM_FORCE_ALIGNED_GENTYPES) || (GLM_CONFIG_SIMD == GLM_ENABLE))
+# define GLM_CONFIG_ALIGNED_GENTYPES GLM_ENABLE
+#else
+# define GLM_CONFIG_ALIGNED_GENTYPES GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of anonymous structure as implementation detail
+
+#if ((GLM_CONFIG_SIMD == GLM_ENABLE) || (GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR) || (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE))
+# define GLM_CONFIG_ANONYMOUS_STRUCT GLM_ENABLE
+#else
+# define GLM_CONFIG_ANONYMOUS_STRUCT GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Silent warnings
+
+#ifdef GLM_FORCE_SILENT_WARNINGS
+# define GLM_SILENT_WARNINGS GLM_ENABLE
+#else
+# define GLM_SILENT_WARNINGS GLM_DISABLE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Precision
+
+#define GLM_HIGHP 1
+#define GLM_MEDIUMP 2
+#define GLM_LOWP 3
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_BOOL) || defined(GLM_PRECISION_HIGHP_BOOL)
+# define GLM_CONFIG_PRECISION_BOOL GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_BOOL) || defined(GLM_PRECISION_MEDIUMP_BOOL)
+# define GLM_CONFIG_PRECISION_BOOL GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_BOOL) || defined(GLM_PRECISION_LOWP_BOOL)
+# define GLM_CONFIG_PRECISION_BOOL GLM_LOWP
+#else
+# define GLM_CONFIG_PRECISION_BOOL GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_INT) || defined(GLM_PRECISION_HIGHP_INT)
+# define GLM_CONFIG_PRECISION_INT GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_INT) || defined(GLM_PRECISION_MEDIUMP_INT)
+# define GLM_CONFIG_PRECISION_INT GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_INT) || defined(GLM_PRECISION_LOWP_INT)
+# define GLM_CONFIG_PRECISION_INT GLM_LOWP
+#else
+# define GLM_CONFIG_PRECISION_INT GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_UINT) || defined(GLM_PRECISION_HIGHP_UINT)
+# define GLM_CONFIG_PRECISION_UINT GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_UINT) || defined(GLM_PRECISION_MEDIUMP_UINT)
+# define GLM_CONFIG_PRECISION_UINT GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_UINT) || defined(GLM_PRECISION_LOWP_UINT)
+# define GLM_CONFIG_PRECISION_UINT GLM_LOWP
+#else
+# define GLM_CONFIG_PRECISION_UINT GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_FLOAT) || defined(GLM_PRECISION_HIGHP_FLOAT)
+# define GLM_CONFIG_PRECISION_FLOAT GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_FLOAT) || defined(GLM_PRECISION_MEDIUMP_FLOAT)
+# define GLM_CONFIG_PRECISION_FLOAT GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_FLOAT) || defined(GLM_PRECISION_LOWP_FLOAT)
+# define GLM_CONFIG_PRECISION_FLOAT GLM_LOWP
+#else
+# define GLM_CONFIG_PRECISION_FLOAT GLM_HIGHP
+#endif
+
+#if defined(GLM_FORCE_PRECISION_HIGHP_DOUBLE) || defined(GLM_PRECISION_HIGHP_DOUBLE)
+# define GLM_CONFIG_PRECISION_DOUBLE GLM_HIGHP
+#elif defined(GLM_FORCE_PRECISION_MEDIUMP_DOUBLE) || defined(GLM_PRECISION_MEDIUMP_DOUBLE)
+# define GLM_CONFIG_PRECISION_DOUBLE GLM_MEDIUMP
+#elif defined(GLM_FORCE_PRECISION_LOWP_DOUBLE) || defined(GLM_PRECISION_LOWP_DOUBLE)
+# define GLM_CONFIG_PRECISION_DOUBLE GLM_LOWP
+#else
+# define GLM_CONFIG_PRECISION_DOUBLE GLM_HIGHP
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Check inclusions of different versions of GLM
+
+#elif ((GLM_SETUP_INCLUDED != GLM_VERSION) && !defined(GLM_FORCE_IGNORE_VERSION))
+# error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error."
+#elif GLM_SETUP_INCLUDED == GLM_VERSION
+
+///////////////////////////////////////////////////////////////////////////////////
+// Messages
+
+#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_DISPLAYED)
+# define GLM_MESSAGE_DISPLAYED
+# define GLM_STR_HELPER(x) #x
+# define GLM_STR(x) GLM_STR_HELPER(x)
+
+ // Report GLM version
+# pragma message (GLM_STR(GLM_VERSION_MESSAGE))
+
+ // Report C++ language
+# if (GLM_LANG & GLM_LANG_CXX2A_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 2A with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX2A_FLAG)
+# pragma message("GLM: C++ 2A")
+# elif (GLM_LANG & GLM_LANG_CXX17_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 17 with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX17_FLAG)
+# pragma message("GLM: C++ 17")
+# elif (GLM_LANG & GLM_LANG_CXX14_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 14 with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX14_FLAG)
+# pragma message("GLM: C++ 14")
+# elif (GLM_LANG & GLM_LANG_CXX11_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 11 with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX11_FLAG)
+# pragma message("GLM: C++ 11")
+# elif (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 0x with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX0X_FLAG)
+# pragma message("GLM: C++ 0x")
+# elif (GLM_LANG & GLM_LANG_CXX03_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 03 with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX03_FLAG)
+# pragma message("GLM: C++ 03")
+# elif (GLM_LANG & GLM_LANG_CXX98_FLAG) && (GLM_LANG & GLM_LANG_EXT)
+# pragma message("GLM: C++ 98 with extensions")
+# elif (GLM_LANG & GLM_LANG_CXX98_FLAG)
+# pragma message("GLM: C++ 98")
+# else
+# pragma message("GLM: C++ language undetected")
+# endif//GLM_LANG
+
+ // Report compiler detection
+# if GLM_COMPILER & GLM_COMPILER_CUDA
+# pragma message("GLM: CUDA compiler detected")
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma message("GLM: Visual C++ compiler detected")
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma message("GLM: Clang compiler detected")
+# elif GLM_COMPILER & GLM_COMPILER_INTEL
+# pragma message("GLM: Intel Compiler detected")
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma message("GLM: GCC compiler detected")
+# else
+# pragma message("GLM: Compiler not detected")
+# endif
+
+ // Report build target
+# if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with AVX2 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_AVX2_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with AVX2 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with AVX instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_AVX_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with AVX instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with SSE4.2 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_SSE42_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with SSE4.2 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with SSE4.1 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_SSE41_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with SSE4.1 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with SSSE3 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_SSSE3_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with SSSE3 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with SSE3 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_SSE3_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with SSE3 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits with SSE2 instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_SSE2_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits with SSE2 instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: x86 64 bits build target")
+# elif (GLM_ARCH & GLM_ARCH_X86_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: x86 32 bits build target")
+
+# elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: ARM 64 bits with Neon instruction set build target")
+# elif (GLM_ARCH & GLM_ARCH_NEON_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: ARM 32 bits with Neon instruction set build target")
+
+# elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: ARM 64 bits build target")
+# elif (GLM_ARCH & GLM_ARCH_ARM_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: ARM 32 bits build target")
+
+# elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: MIPS 64 bits build target")
+# elif (GLM_ARCH & GLM_ARCH_MIPS_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: MIPS 32 bits build target")
+
+# elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_64)
+# pragma message("GLM: PowerPC 64 bits build target")
+# elif (GLM_ARCH & GLM_ARCH_PPC_BIT) && (GLM_MODEL == GLM_MODEL_32)
+# pragma message("GLM: PowerPC 32 bits build target")
+# else
+# pragma message("GLM: Unknown build target")
+# endif//GLM_ARCH
+
+ // Report platform name
+# if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
+# pragma message("GLM: QNX platform detected")
+//# elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
+//# pragma message("GLM: iOS platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
+# pragma message("GLM: Apple platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
+# pragma message("GLM: WinCE platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+# pragma message("GLM: Windows platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
+# pragma message("GLM: Native Client detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+# pragma message("GLM: Android platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
+# pragma message("GLM: Linux platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
+# pragma message("GLM: UNIX platform detected")
+# elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
+# pragma message("GLM: platform unknown")
+# else
+# pragma message("GLM: platform not detected")
+# endif
+
+ // Report whether only xyzw component are used
+# if defined GLM_FORCE_XYZW_ONLY
+# pragma message("GLM: GLM_FORCE_XYZW_ONLY is defined. Only x, y, z and w component are available in vector type. This define disables swizzle operators and SIMD instruction sets.")
+# endif
+
+ // Report swizzle operator support
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+# pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling operators enabled.")
+# elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+# pragma message("GLM: GLM_FORCE_SWIZZLE is defined, swizzling functions enabled. Enable compiler C++ language extensions to enable swizzle operators.")
+# else
+# pragma message("GLM: GLM_FORCE_SWIZZLE is undefined. swizzling functions or operators are disabled.")
+# endif
+
+ // Report .length() type
+# if GLM_CONFIG_LENGTH_TYPE == GLM_LENGTH_SIZE_T
+# pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is defined. .length() returns a glm::length_t, a typedef of std::size_t.")
+# else
+# pragma message("GLM: GLM_FORCE_SIZE_T_LENGTH is undefined. .length() returns a glm::length_t, a typedef of int following GLSL.")
+# endif
+
+# if GLM_CONFIG_UNRESTRICTED_GENTYPE == GLM_ENABLE
+# pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is defined. Removes GLSL restrictions on valid function genTypes.")
+# else
+# pragma message("GLM: GLM_FORCE_UNRESTRICTED_GENTYPE is undefined. Follows strictly GLSL on valid function genTypes.")
+# endif
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is defined. Ignores C++ warnings from using C++ language extensions.")
+# else
+# pragma message("GLM: GLM_FORCE_SILENT_WARNINGS is undefined. Shows C++ warnings from using C++ language extensions.")
+# endif
+
+# ifdef GLM_FORCE_SINGLE_ONLY
+# pragma message("GLM: GLM_FORCE_SINGLE_ONLY is defined. Using only single precision floating-point types.")
+# endif
+
+# if defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE)
+# undef GLM_FORCE_ALIGNED_GENTYPES
+# pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined, allowing aligned types. This prevents the use of C++ constexpr.")
+# elif defined(GLM_FORCE_ALIGNED_GENTYPES) && (GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE)
+# undef GLM_FORCE_ALIGNED_GENTYPES
+# pragma message("GLM: GLM_FORCE_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.")
+# endif
+
+# if defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_DISABLE
+# undef GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+# pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined but is disabled. It requires C++11 and language extensions.")
+# elif GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+# pragma message("GLM: GLM_FORCE_DEFAULT_ALIGNED_GENTYPES is defined. All gentypes (e.g. vec3) will be aligned and padded by default.")
+# endif
+# endif
+
+# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_ZO_BIT
+# pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is defined. Using zero to one depth clip space.")
+# else
+# pragma message("GLM: GLM_FORCE_DEPTH_ZERO_TO_ONE is undefined. Using negative one to one depth clip space.")
+# endif
+
+# if GLM_CONFIG_CLIP_CONTROL & GLM_CLIP_CONTROL_LH_BIT
+# pragma message("GLM: GLM_FORCE_LEFT_HANDED is defined. Using left handed coordinate system.")
+# else
+# pragma message("GLM: GLM_FORCE_LEFT_HANDED is undefined. Using right handed coordinate system.")
+# endif
+#endif//GLM_MESSAGES
+
+#endif//GLM_SETUP_INCLUDED
diff --git a/src/include/glm/detail/type_float.hpp b/src/include/glm/detail/type_float.hpp new file mode 100644 index 0000000..34b33fa --- /dev/null +++ b/src/include/glm/detail/type_float.hpp @@ -0,0 +1,68 @@ +#pragma once
+
+#include "setup.hpp"
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+# pragma warning(push)
+# pragma warning(disable: 4512) // assignment operator could not be generated
+#endif
+
+namespace glm{
+namespace detail
+{
+ template <typename T>
+ union float_t
+ {};
+
+ // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+ template <>
+ union float_t<float>
+ {
+ typedef int int_type;
+ typedef float float_type;
+
+ GLM_CONSTEXPR float_t(float_type Num = 0.0f) : f(Num) {}
+
+ GLM_CONSTEXPR float_t& operator=(float_t const& x)
+ {
+ f = x.f;
+ return *this;
+ }
+
+ // Portable extraction of components.
+ GLM_CONSTEXPR bool negative() const { return i < 0; }
+ GLM_CONSTEXPR int_type mantissa() const { return i & ((1 << 23) - 1); }
+ GLM_CONSTEXPR int_type exponent() const { return (i >> 23) & ((1 << 8) - 1); }
+
+ int_type i;
+ float_type f;
+ };
+
+ template <>
+ union float_t<double>
+ {
+ typedef detail::int64 int_type;
+ typedef double float_type;
+
+ GLM_CONSTEXPR float_t(float_type Num = static_cast<float_type>(0)) : f(Num) {}
+
+ GLM_CONSTEXPR float_t& operator=(float_t const& x)
+ {
+ f = x.f;
+ return *this;
+ }
+
+ // Portable extraction of components.
+ GLM_CONSTEXPR bool negative() const { return i < 0; }
+ GLM_CONSTEXPR int_type mantissa() const { return i & ((int_type(1) << 52) - 1); }
+ GLM_CONSTEXPR int_type exponent() const { return (i >> 52) & ((int_type(1) << 11) - 1); }
+
+ int_type i;
+ float_type f;
+ };
+}//namespace detail
+}//namespace glm
+
+#if GLM_COMPILER == GLM_COMPILER_VC12
+# pragma warning(pop)
+#endif
diff --git a/src/include/glm/detail/type_half.hpp b/src/include/glm/detail/type_half.hpp new file mode 100644 index 0000000..6a71e38 --- /dev/null +++ b/src/include/glm/detail/type_half.hpp @@ -0,0 +1,16 @@ +#pragma once
+
+#include "setup.hpp"
+
+namespace glm{
+namespace detail
+{
+ typedef short hdata;
+
+ GLM_FUNC_DECL float toFloat32(hdata value);
+ GLM_FUNC_DECL hdata toFloat16(float const& value);
+
+}//namespace detail
+}//namespace glm
+
+#include "type_half.inl"
diff --git a/src/include/glm/detail/type_half.inl b/src/include/glm/detail/type_half.inl new file mode 100644 index 0000000..5c161cb --- /dev/null +++ b/src/include/glm/detail/type_half.inl @@ -0,0 +1,241 @@ +namespace glm{
+namespace detail
+{
+ GLM_FUNC_QUALIFIER float overflow()
+ {
+ volatile float f = 1e10;
+
+ for(int i = 0; i < 10; ++i)
+ f *= f; // this will overflow before the for loop terminates
+ return f;
+ }
+
+ union uif32
+ {
+ GLM_FUNC_QUALIFIER uif32() :
+ i(0)
+ {}
+
+ GLM_FUNC_QUALIFIER uif32(float f_) :
+ f(f_)
+ {}
+
+ GLM_FUNC_QUALIFIER uif32(unsigned int i_) :
+ i(i_)
+ {}
+
+ float f;
+ unsigned int i;
+ };
+
+ GLM_FUNC_QUALIFIER float toFloat32(hdata value)
+ {
+ int s = (value >> 15) & 0x00000001;
+ int e = (value >> 10) & 0x0000001f;
+ int m = value & 0x000003ff;
+
+ if(e == 0)
+ {
+ if(m == 0)
+ {
+ //
+ // Plus or minus zero
+ //
+
+ detail::uif32 result;
+ result.i = static_cast<unsigned int>(s << 31);
+ return result.f;
+ }
+ else
+ {
+ //
+ // Denormalized number -- renormalize it
+ //
+
+ while(!(m & 0x00000400))
+ {
+ m <<= 1;
+ e -= 1;
+ }
+
+ e += 1;
+ m &= ~0x00000400;
+ }
+ }
+ else if(e == 31)
+ {
+ if(m == 0)
+ {
+ //
+ // Positive or negative infinity
+ //
+
+ uif32 result;
+ result.i = static_cast<unsigned int>((s << 31) | 0x7f800000);
+ return result.f;
+ }
+ else
+ {
+ //
+ // Nan -- preserve sign and significand bits
+ //
+
+ uif32 result;
+ result.i = static_cast<unsigned int>((s << 31) | 0x7f800000 | (m << 13));
+ return result.f;
+ }
+ }
+
+ //
+ // Normalized number
+ //
+
+ e = e + (127 - 15);
+ m = m << 13;
+
+ //
+ // Assemble s, e and m.
+ //
+
+ uif32 Result;
+ Result.i = static_cast<unsigned int>((s << 31) | (e << 23) | m);
+ return Result.f;
+ }
+
+ GLM_FUNC_QUALIFIER hdata toFloat16(float const& f)
+ {
+ uif32 Entry;
+ Entry.f = f;
+ int i = static_cast<int>(Entry.i);
+
+ //
+ // Our floating point number, f, is represented by the bit
+ // pattern in integer i. Disassemble that bit pattern into
+ // the sign, s, the exponent, e, and the significand, m.
+ // Shift s into the position where it will go in the
+ // resulting half number.
+ // Adjust e, accounting for the different exponent bias
+ // of float and half (127 versus 15).
+ //
+
+ int s = (i >> 16) & 0x00008000;
+ int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+ int m = i & 0x007fffff;
+
+ //
+ // Now reassemble s, e and m into a half:
+ //
+
+ if(e <= 0)
+ {
+ if(e < -10)
+ {
+ //
+ // E is less than -10. The absolute value of f is
+ // less than half_MIN (f may be a small normalized
+ // float, a denormalized float or a zero).
+ //
+ // We convert f to a half zero.
+ //
+
+ return hdata(s);
+ }
+
+ //
+ // E is between -10 and 0. F is a normalized float,
+ // whose magnitude is less than __half_NRM_MIN.
+ //
+ // We convert f to a denormalized half.
+ //
+
+ m = (m | 0x00800000) >> (1 - e);
+
+ //
+ // Round to nearest, round "0.5" up.
+ //
+ // Rounding may cause the significand to overflow and make
+ // our number normalized. Because of the way a half's bits
+ // are laid out, we don't have to treat this case separately;
+ // the code below will handle it correctly.
+ //
+
+ if(m & 0x00001000)
+ m += 0x00002000;
+
+ //
+ // Assemble the half from s, e (zero) and m.
+ //
+
+ return hdata(s | (m >> 13));
+ }
+ else if(e == 0xff - (127 - 15))
+ {
+ if(m == 0)
+ {
+ //
+ // F is an infinity; convert f to a half
+ // infinity with the same sign as f.
+ //
+
+ return hdata(s | 0x7c00);
+ }
+ else
+ {
+ //
+ // F is a NAN; we produce a half NAN that preserves
+ // the sign bit and the 10 leftmost bits of the
+ // significand of f, with one exception: If the 10
+ // leftmost bits are all zero, the NAN would turn
+ // into an infinity, so we have to set at least one
+ // bit in the significand.
+ //
+
+ m >>= 13;
+
+ return hdata(s | 0x7c00 | m | (m == 0));
+ }
+ }
+ else
+ {
+ //
+ // E is greater than zero. F is a normalized float.
+ // We try to convert f to a normalized half.
+ //
+
+ //
+ // Round to nearest, round "0.5" up
+ //
+
+ if(m & 0x00001000)
+ {
+ m += 0x00002000;
+
+ if(m & 0x00800000)
+ {
+ m = 0; // overflow in significand,
+ e += 1; // adjust exponent
+ }
+ }
+
+ //
+ // Handle exponent overflow
+ //
+
+ if (e > 30)
+ {
+ overflow(); // Cause a hardware floating point overflow;
+
+ return hdata(s | 0x7c00);
+ // if this returns, the half becomes an
+ } // infinity with the same sign as f.
+
+ //
+ // Assemble the half from s, e and m.
+ //
+
+ return hdata(s | (e << 10) | (m >> 13));
+ }
+ }
+
+}//namespace detail
+}//namespace glm
diff --git a/src/include/glm/detail/type_mat2x2.hpp b/src/include/glm/detail/type_mat2x2.hpp new file mode 100644 index 0000000..c145b13 --- /dev/null +++ b/src/include/glm/detail/type_mat2x2.hpp @@ -0,0 +1,177 @@ +/// @ref core
+/// @file glm/detail/type_mat2x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<2, 2, T, Q>
+ {
+ typedef vec<2, T, Q> col_type;
+ typedef vec<2, T, Q> row_type;
+ typedef mat<2, 2, T, Q> type;
+ typedef mat<2, 2, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[2];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 2, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T const& x1, T const& y1,
+ T const& x2, T const& y2);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v1,
+ col_type const& v2);
+
+ // -- Conversions --
+
+ template<typename U, typename V, typename M, typename N>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ U const& x1, V const& y1,
+ M const& x2, N const& y2);
+
+ template<typename U, typename V>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<2, U, Q> const& v1,
+ vec<2, V, Q> const& v2);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator++ ();
+ GLM_FUNC_DECL mat<2, 2, T, Q> & operator-- ();
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator*(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator*(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x2.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat2x2.inl b/src/include/glm/detail/type_mat2x2.inl new file mode 100644 index 0000000..acd773f --- /dev/null +++ b/src/include/glm/detail/type_mat2x2.inl @@ -0,0 +1,536 @@ +#include "../matrix.hpp"
+
+namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0), col_type(0, 1)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0);
+ this->value[1] = col_type(0, 1);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{m[0], m[1]}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(T scalar)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(scalar, 0), col_type(0, scalar)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(scalar, 0);
+ this->value[1] = col_type(0, scalar);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+ (
+ T const& x0, T const& y0,
+ T const& x1, T const& y1
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0), col_type(x1, y1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0);
+ this->value[1] = col_type(x1, y1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{v0, v1}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<typename X1, typename Y1, typename X2, typename Y2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
+ (
+ X1 const& x1, Y1 const& y1,
+ X2 const& x2, Y2 const& y2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(static_cast<T>(x1), value_type(y1)), col_type(static_cast<T>(x2), value_type(y2)) }
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
+ this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+# endif
+ }
+
+ // -- mat2x2 matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 2, T, Q>::col_type const& mat<2, 2, T, Q>::operator[](typename mat<2, 2, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator=(mat<2, 2, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(U scalar)
+ {
+ this->value[0] += scalar;
+ this->value[1] += scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator+=(mat<2, 2, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(U scalar)
+ {
+ this->value[0] -= scalar;
+ this->value[1] -= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator-=(mat<2, 2, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(U scalar)
+ {
+ this->value[0] *= scalar;
+ this->value[1] *= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator*=(mat<2, 2, U, Q> const& m)
+ {
+ return (*this = *this * m);
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(U scalar)
+ {
+ this->value[0] /= scalar;
+ this->value[1] /= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator/=(mat<2, 2, U, Q> const& m)
+ {
+ return *this *= inverse(m);
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q>& mat<2, 2, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator++(int)
+ {
+ mat<2, 2, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> mat<2, 2, T, Q>::operator--(int)
+ {
+ mat<2, 2, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m)
+ {
+ return mat<2, 2, T, Q>(
+ -m[0],
+ -m[1]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m, T scalar)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(T scalar, mat<2, 2, T, Q> const& m)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator+(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return mat<2, 2, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m, T scalar)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(T scalar, mat<2, 2, T, Q> const& m)
+ {
+ return mat<2, 2, T, Q>(
+ scalar - m[0],
+ scalar - m[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator-(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return mat<2, 2, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m, T scalar)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(T scalar, mat<2, 2, T, Q> const& m)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator*
+ (
+ mat<2, 2, T, Q> const& m,
+ typename mat<2, 2, T, Q>::row_type const& v
+ )
+ {
+ return vec<2, T, Q>(
+ m[0][0] * v.x + m[1][0] * v.y,
+ m[0][1] * v.x + m[1][1] * v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator*
+ (
+ typename mat<2, 2, T, Q>::col_type const& v,
+ mat<2, 2, T, Q> const& m
+ )
+ {
+ return vec<2, T, Q>(
+ v.x * m[0][0] + v.y * m[0][1],
+ v.x * m[1][0] + v.y * m[1][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return mat<2, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return mat<3, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<2, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return mat<4, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m, T scalar)
+ {
+ return mat<2, 2, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(T scalar, mat<2, 2, T, Q> const& m)
+ {
+ return mat<2, 2, T, Q>(
+ scalar / m[0],
+ scalar / m[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::col_type operator/(mat<2, 2, T, Q> const& m, typename mat<2, 2, T, Q>::row_type const& v)
+ {
+ return inverse(m) * v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 2, T, Q>::row_type operator/(typename mat<2, 2, T, Q>::col_type const& v, mat<2, 2, T, Q> const& m)
+ {
+ return v * inverse(m);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator/(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ mat<2, 2, T, Q> m1_copy(m1);
+ return m1_copy /= m2;
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat2x3.hpp b/src/include/glm/detail/type_mat2x3.hpp new file mode 100644 index 0000000..81e0407 --- /dev/null +++ b/src/include/glm/detail/type_mat2x3.hpp @@ -0,0 +1,159 @@ +/// @ref core
+/// @file glm/detail/type_mat2x3.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<2, 3, T, Q>
+ {
+ typedef vec<3, T, Q> col_type;
+ typedef vec<2, T, Q> row_type;
+ typedef mat<2, 3, T, Q> type;
+ typedef mat<3, 2, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[2];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 3, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0, T z0,
+ T x1, T y1, T z1);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1);
+
+ // -- Conversions --
+
+ template<typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 x1, Y1 y1, Z1 z1,
+ X2 x2, Y2 y2, Z2 z2);
+
+ template<typename U, typename V>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<3, U, Q> const& v1,
+ vec<3, V, Q> const& v2);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator+=(mat<2, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator-=(mat<2, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator++ ();
+ GLM_FUNC_DECL mat<2, 3, T, Q> & operator-- ();
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 3, T, Q>::col_type operator*(mat<2, 3, T, Q> const& m, typename mat<2, 3, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 3, T, Q>::row_type operator*(typename mat<2, 3, T, Q>::col_type const& v, mat<2, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x3.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat2x3.inl b/src/include/glm/detail/type_mat2x3.inl new file mode 100644 index 0000000..cf17f49 --- /dev/null +++ b/src/include/glm/detail/type_mat2x3.inl @@ -0,0 +1,510 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0), col_type(0, 1, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0);
+ this->value[1] = col_type(0, 1, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{m.value[0], m.value[1]}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m.value[0];
+ this->value[1] = m.value[1];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(T scalar)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(scalar, 0, 0), col_type(0, scalar, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(scalar, 0, 0);
+ this->value[1] = col_type(0, scalar, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+ (
+ T x0, T y0, T z0,
+ T x1, T y1, T z1
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0, z0), col_type(x1, y1, z1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0);
+ this->value[1] = col_type(x1, y1, z1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v0);
+ this->value[1] = col_type(v1);
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X1, typename Y1, typename Z1,
+ typename X2, typename Y2, typename Z2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
+ (
+ X1 x1, Y1 y1, Z1 z1,
+ X2 x2, Y2 y2, Z2 z2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x1, y1, z1), col_type(x2, y2, z2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x1, y1, z1);
+ this->value[1] = col_type(x2, y2, z2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type & mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 3, T, Q>::col_type const& mat<2, 3, T, Q>::operator[](typename mat<2, 3, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator=(mat<2, 3, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator+=(mat<2, 3, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator-=(mat<2, 3, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q>& mat<2, 3, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> & mat<2, 3, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator++(int)
+ {
+ mat<2, 3, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> mat<2, 3, T, Q>::operator--(int)
+ {
+ mat<2, 3, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m)
+ {
+ return mat<2, 3, T, Q>(
+ -m[0],
+ -m[1]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m, T scalar)
+ {
+ return mat<2, 3, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator+(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return mat<2, 3, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m, T scalar)
+ {
+ return mat<2, 3, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator-(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return mat<2, 3, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m, T scalar)
+ {
+ return mat<2, 3, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(T scalar, mat<2, 3, T, Q> const& m)
+ {
+ return mat<2, 3, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::col_type operator*
+ (
+ mat<2, 3, T, Q> const& m,
+ typename mat<2, 3, T, Q>::row_type const& v)
+ {
+ return typename mat<2, 3, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y,
+ m[0][1] * v.x + m[1][1] * v.y,
+ m[0][2] * v.x + m[1][2] * v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 3, T, Q>::row_type operator*
+ (
+ typename mat<2, 3, T, Q>::col_type const& v,
+ mat<2, 3, T, Q> const& m)
+ {
+ return typename mat<2, 3, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+ v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return mat<2, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ T SrcA00 = m1[0][0];
+ T SrcA01 = m1[0][1];
+ T SrcA02 = m1[0][2];
+ T SrcA10 = m1[1][0];
+ T SrcA11 = m1[1][1];
+ T SrcA12 = m1[1][2];
+
+ T SrcB00 = m2[0][0];
+ T SrcB01 = m2[0][1];
+ T SrcB10 = m2[1][0];
+ T SrcB11 = m2[1][1];
+ T SrcB20 = m2[2][0];
+ T SrcB21 = m2[2][1];
+
+ mat<3, 3, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+ Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+ Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+ Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+ Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+ Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<2, 3, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return mat<4, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
+ m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(mat<2, 3, T, Q> const& m, T scalar)
+ {
+ return mat<2, 3, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator/(T scalar, mat<2, 3, T, Q> const& m)
+ {
+ return mat<2, 3, T, Q>(
+ scalar / m[0],
+ scalar / m[1]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat2x4.hpp b/src/include/glm/detail/type_mat2x4.hpp new file mode 100644 index 0000000..17893d6 --- /dev/null +++ b/src/include/glm/detail/type_mat2x4.hpp @@ -0,0 +1,161 @@ +/// @ref core
+/// @file glm/detail/type_mat2x4.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<2, 4, T, Q>
+ {
+ typedef vec<4, T, Q> col_type;
+ typedef vec<2, T, Q> row_type;
+ typedef mat<2, 4, T, Q> type;
+ typedef mat<4, 2, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[2];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<2, 4, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0, T z0, T w0,
+ T x1, T y1, T z1, T w1);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 x1, Y1 y1, Z1 z1, W1 w1,
+ X2 x2, Y2 y2, Z2 z2, W2 w2);
+
+ template<typename U, typename V>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<4, U, Q> const& v1,
+ vec<4, V, Q> const& v2);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator++ ();
+ GLM_FUNC_DECL mat<2, 4, T, Q> & operator-- ();
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x4.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat2x4.inl b/src/include/glm/detail/type_mat2x4.inl new file mode 100644 index 0000000..3ab92b0 --- /dev/null +++ b/src/include/glm/detail/type_mat2x4.inl @@ -0,0 +1,520 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0, 0);
+ this->value[1] = col_type(0, 1, 0, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{m[0], m[1]}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(T s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0, 0, 0);
+ this->value[1] = col_type(0, s, 0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+ (
+ T x0, T y0, T z0, T w0,
+ T x1, T y1, T z1, T w1
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0, w0);
+ this->value[1] = col_type(x1, y1, z1, w1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
+ (
+ X1 x1, Y1 y1, Z1 z1, W1 w1,
+ X2 x2, Y2 y2, Z2 z2, W2 w2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{
+ col_type(x1, y1, z1, w1),
+ col_type(x2, y2, z2, w2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x1, y1, z1, w1);
+ this->value[1] = col_type(x2, y2, z2, w2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type & mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<2, 4, T, Q>::col_type const& mat<2, 4, T, Q>::operator[](typename mat<2, 4, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator=(mat<2, 4, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator+=(mat<2, 4, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator-=(mat<2, 4, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> & mat<2, 4, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q>& mat<2, 4, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator++(int)
+ {
+ mat<2, 4, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> mat<2, 4, T, Q>::operator--(int)
+ {
+ mat<2, 4, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m)
+ {
+ return mat<2, 4, T, Q>(
+ -m[0],
+ -m[1]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m, T scalar)
+ {
+ return mat<2, 4, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator+(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return mat<2, 4, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m, T scalar)
+ {
+ return mat<2, 4, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator-(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return mat<2, 4, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m, T scalar)
+ {
+ return mat<2, 4, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(T scalar, mat<2, 4, T, Q> const& m)
+ {
+ return mat<2, 4, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::col_type operator*(mat<2, 4, T, Q> const& m, typename mat<2, 4, T, Q>::row_type const& v)
+ {
+ return typename mat<2, 4, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y,
+ m[0][1] * v.x + m[1][1] * v.y,
+ m[0][2] * v.x + m[1][2] * v.y,
+ m[0][3] * v.x + m[1][3] * v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<2, 4, T, Q>::row_type operator*(typename mat<2, 4, T, Q>::col_type const& v, mat<2, 4, T, Q> const& m)
+ {
+ return typename mat<2, 4, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+ v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ T SrcA00 = m1[0][0];
+ T SrcA01 = m1[0][1];
+ T SrcA02 = m1[0][2];
+ T SrcA03 = m1[0][3];
+ T SrcA10 = m1[1][0];
+ T SrcA11 = m1[1][1];
+ T SrcA12 = m1[1][2];
+ T SrcA13 = m1[1][3];
+
+ T SrcB00 = m2[0][0];
+ T SrcB01 = m2[0][1];
+ T SrcB10 = m2[1][0];
+ T SrcB11 = m2[1][1];
+ T SrcB20 = m2[2][0];
+ T SrcB21 = m2[2][1];
+ T SrcB30 = m2[3][0];
+ T SrcB31 = m2[3][1];
+
+ mat<4, 4, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+ Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+ Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+ Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+ Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
+ Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+ Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+ Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+ Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
+ Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
+ Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
+ Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
+ Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<2, 2, T, Q> const& m2)
+ {
+ return mat<2, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<2, 4, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return mat<3, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
+ m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(mat<2, 4, T, Q> const& m, T scalar)
+ {
+ return mat<2, 4, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator/(T scalar, mat<2, 4, T, Q> const& m)
+ {
+ return mat<2, 4, T, Q>(
+ scalar / m[0],
+ scalar / m[1]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat3x2.hpp b/src/include/glm/detail/type_mat3x2.hpp new file mode 100644 index 0000000..1f06bce --- /dev/null +++ b/src/include/glm/detail/type_mat3x2.hpp @@ -0,0 +1,167 @@ +/// @ref core
+/// @file glm/detail/type_mat3x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<3, 2, T, Q>
+ {
+ typedef vec<2, T, Q> col_type;
+ typedef vec<3, T, Q> row_type;
+ typedef mat<3, 2, T, Q> type;
+ typedef mat<2, 3, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[3];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 2, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0,
+ T x1, T y1,
+ T x2, T y2);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1,
+ typename X2, typename Y2,
+ typename X3, typename Y3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 x1, Y1 y1,
+ X2 x2, Y2 y2,
+ X3 x3, Y3 y3);
+
+ template<typename V1, typename V2, typename V3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<2, V1, Q> const& v1,
+ vec<2, V2, Q> const& v2,
+ vec<2, V3, Q> const& v3);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator+=(mat<3, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator-=(mat<3, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator++ ();
+ GLM_FUNC_DECL mat<3, 2, T, Q> & operator-- ();
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2);
+
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x2.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat3x2.inl b/src/include/glm/detail/type_mat3x2.inl new file mode 100644 index 0000000..4e03854 --- /dev/null +++ b/src/include/glm/detail/type_mat3x2.inl @@ -0,0 +1,532 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0), col_type(0, 1), col_type(0, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0);
+ this->value[1] = col_type(0, 1);
+ this->value[2] = col_type(0, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(T s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0), col_type(0, s), col_type(0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0);
+ this->value[1] = col_type(0, s);
+ this->value[2] = col_type(0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+ (
+ T x0, T y0,
+ T x1, T y1,
+ T x2, T y2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0);
+ this->value[1] = col_type(x1, y1);
+ this->value[2] = col_type(x2, y2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+ this->value[2] = v2;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X0, typename Y0,
+ typename X1, typename Y1,
+ typename X2, typename Y2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
+ (
+ X0 x0, Y0 y0,
+ X1 x1, Y1 y1,
+ X2 x2, Y2 y2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0);
+ this->value[1] = col_type(x1, y1);
+ this->value[2] = col_type(x2, y2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V0, typename V1, typename V2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v0);
+ this->value[1] = col_type(v1);
+ this->value[2] = col_type(v2);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type & mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 2, T, Q>::col_type const& mat<3, 2, T, Q>::operator[](typename mat<3, 2, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator=(mat<3, 2, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator+=(mat<3, 2, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator-=(mat<3, 2, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> & mat<3, 2, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q>& mat<3, 2, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator++(int)
+ {
+ mat<3, 2, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> mat<3, 2, T, Q>::operator--(int)
+ {
+ mat<3, 2, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m)
+ {
+ return mat<3, 2, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m, T scalar)
+ {
+ return mat<3, 2, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar,
+ m[2] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator+(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return mat<3, 2, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m, T scalar)
+ {
+ return mat<3, 2, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar,
+ m[2] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator-(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return mat<3, 2, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m, T scalar)
+ {
+ return mat<3, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(T scalar, mat<3, 2, T, Q> const& m)
+ {
+ return mat<3, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::col_type operator*(mat<3, 2, T, Q> const& m, typename mat<3, 2, T, Q>::row_type const& v)
+ {
+ return typename mat<3, 2, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+ m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 2, T, Q>::row_type operator*(typename mat<3, 2, T, Q>::col_type const& v, mat<3, 2, T, Q> const& m)
+ {
+ return typename mat<3, 2, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1],
+ v.x * m[1][0] + v.y * m[1][1],
+ v.x * m[2][0] + v.y * m[2][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ const T SrcA00 = m1[0][0];
+ const T SrcA01 = m1[0][1];
+ const T SrcA10 = m1[1][0];
+ const T SrcA11 = m1[1][1];
+ const T SrcA20 = m1[2][0];
+ const T SrcA21 = m1[2][1];
+
+ const T SrcB00 = m2[0][0];
+ const T SrcB01 = m2[0][1];
+ const T SrcB02 = m2[0][2];
+ const T SrcB10 = m2[1][0];
+ const T SrcB11 = m2[1][1];
+ const T SrcB12 = m2[1][2];
+
+ mat<2, 2, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return mat<3, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<3, 2, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return mat<4, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(mat<3, 2, T, Q> const& m, T scalar)
+ {
+ return mat<3, 2, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar,
+ m[2] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator/(T scalar, mat<3, 2, T, Q> const& m)
+ {
+ return mat<3, 2, T, Q>(
+ scalar / m[0],
+ scalar / m[1],
+ scalar / m[2]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, Q> const& m1, mat<3, 2, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat3x3.hpp b/src/include/glm/detail/type_mat3x3.hpp new file mode 100644 index 0000000..b3255f5 --- /dev/null +++ b/src/include/glm/detail/type_mat3x3.hpp @@ -0,0 +1,184 @@ +/// @ref core
+/// @file glm/detail/type_mat3x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<3, 3, T, Q>
+ {
+ typedef vec<3, T, Q> col_type;
+ typedef vec<3, T, Q> row_type;
+ typedef mat<3, 3, T, Q> type;
+ typedef mat<3, 3, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[3];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 3, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0, T z0,
+ T x1, T y1, T z1,
+ T x2, T y2, T z2);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1, typename Z1,
+ typename X2, typename Y2, typename Z2,
+ typename X3, typename Y3, typename Z3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 x1, Y1 y1, Z1 z1,
+ X2 x2, Y2 y2, Z2 z2,
+ X3 x3, Y3 y3, Z3 z3);
+
+ template<typename V1, typename V2, typename V3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<3, V1, Q> const& v1,
+ vec<3, V2, Q> const& v2,
+ vec<3, V3, Q> const& v3);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator++();
+ GLM_FUNC_DECL mat<3, 3, T, Q> & operator--();
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x3.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat3x3.inl b/src/include/glm/detail/type_mat3x3.inl new file mode 100644 index 0000000..b156592 --- /dev/null +++ b/src/include/glm/detail/type_mat3x3.inl @@ -0,0 +1,601 @@ +#include "../matrix.hpp"
+
+namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0);
+ this->value[1] = col_type(0, 1, 0);
+ this->value[2] = col_type(0, 0, 1);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(T s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0, 0);
+ this->value[1] = col_type(0, s, 0);
+ this->value[2] = col_type(0, 0, s);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+ (
+ T x0, T y0, T z0,
+ T x1, T y1, T z1,
+ T x2, T y2, T z2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0);
+ this->value[1] = col_type(x1, y1, z1);
+ this->value[2] = col_type(x2, y2, z2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v0);
+ this->value[1] = col_type(v1);
+ this->value[2] = col_type(v2);
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X1, typename Y1, typename Z1,
+ typename X2, typename Y2, typename Z2,
+ typename X3, typename Y3, typename Z3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
+ (
+ X1 x1, Y1 y1, Z1 z1,
+ X2 x2, Y2 y2, Z2 z2,
+ X3 x3, Y3 y3, Z3 z3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x1, y1, z1);
+ this->value[1] = col_type(x2, y2, z2);
+ this->value[2] = col_type(x3, y3, z3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2, typename V3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2), col_type(v3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+ this->value[2] = col_type(v3);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type & mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::col_type const& mat<3, 3, T, Q>::operator[](typename mat<3, 3, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator=(mat<3, 3, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator+=(mat<3, 3, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator-=(mat<3, 3, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator*=(mat<3, 3, U, Q> const& m)
+ {
+ return (*this = *this * m);
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator/=(mat<3, 3, U, Q> const& m)
+ {
+ return *this *= inverse(m);
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> & mat<3, 3, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator++(int)
+ {
+ mat<3, 3, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> mat<3, 3, T, Q>::operator--(int)
+ {
+ mat<3, 3, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m)
+ {
+ return mat<3, 3, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m, T scalar)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar,
+ m[2] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(T scalar, mat<3, 3, T, Q> const& m)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar,
+ m[2] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator+(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return mat<3, 3, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m, T scalar)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar,
+ m[2] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(T scalar, mat<3, 3, T, Q> const& m)
+ {
+ return mat<3, 3, T, Q>(
+ scalar - m[0],
+ scalar - m[1],
+ scalar - m[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator-(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return mat<3, 3, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m, T scalar)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(T scalar, mat<3, 3, T, Q> const& m)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator*(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+ {
+ return typename mat<3, 3, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+ m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+ m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator*(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+ {
+ return typename mat<3, 3, T, Q>::row_type(
+ m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
+ m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
+ m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ T const SrcA00 = m1[0][0];
+ T const SrcA01 = m1[0][1];
+ T const SrcA02 = m1[0][2];
+ T const SrcA10 = m1[1][0];
+ T const SrcA11 = m1[1][1];
+ T const SrcA12 = m1[1][2];
+ T const SrcA20 = m1[2][0];
+ T const SrcA21 = m1[2][1];
+ T const SrcA22 = m1[2][2];
+
+ T const SrcB00 = m2[0][0];
+ T const SrcB01 = m2[0][1];
+ T const SrcB02 = m2[0][2];
+ T const SrcB10 = m2[1][0];
+ T const SrcB11 = m2[1][1];
+ T const SrcB12 = m2[1][2];
+ T const SrcB20 = m2[2][0];
+ T const SrcB21 = m2[2][1];
+ T const SrcB22 = m2[2][2];
+
+ mat<3, 3, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+ Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+ Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+ Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+ Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+ Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return mat<2, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<3, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return mat<4, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
+ m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m, T scalar)
+ {
+ return mat<3, 3, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar,
+ m[2] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(T scalar, mat<3, 3, T, Q> const& m)
+ {
+ return mat<3, 3, T, Q>(
+ scalar / m[0],
+ scalar / m[1],
+ scalar / m[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::col_type operator/(mat<3, 3, T, Q> const& m, typename mat<3, 3, T, Q>::row_type const& v)
+ {
+ return inverse(m) * v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 3, T, Q>::row_type operator/(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+ {
+ return v * inverse(m);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator/(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ mat<3, 3, T, Q> m1_copy(m1);
+ return m1_copy /= m2;
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat3x4.hpp b/src/include/glm/detail/type_mat3x4.hpp new file mode 100644 index 0000000..afffd7b --- /dev/null +++ b/src/include/glm/detail/type_mat3x4.hpp @@ -0,0 +1,166 @@ +/// @ref core
+/// @file glm/detail/type_mat3x4.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<3, 4, T, Q>
+ {
+ typedef vec<4, T, Q> col_type;
+ typedef vec<3, T, Q> row_type;
+ typedef mat<3, 4, T, Q> type;
+ typedef mat<4, 3, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[3];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<3, 4, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0, T z0, T w0,
+ T x1, T y1, T z1, T w1,
+ T x2, T y2, T z2, T w2);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2,
+ typename X3, typename Y3, typename Z3, typename W3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 x1, Y1 y1, Z1 z1, W1 w1,
+ X2 x2, Y2 y2, Z2 z2, W2 w2,
+ X3 x3, Y3 y3, Z3 z3, W3 w3);
+
+ template<typename V1, typename V2, typename V3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<4, V1, Q> const& v1,
+ vec<4, V2, Q> const& v2,
+ vec<4, V3, Q> const& v3);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator++();
+ GLM_FUNC_DECL mat<3, 4, T, Q> & operator--();
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 4, T, Q>::col_type operator*(mat<3, 4, T, Q> const& m, typename mat<3, 4, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<3, 4, T, Q>::row_type operator*(typename mat<3, 4, T, Q>::col_type const& v, mat<3, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x4.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat3x4.inl b/src/include/glm/detail/type_mat3x4.inl new file mode 100644 index 0000000..8e94bfc --- /dev/null +++ b/src/include/glm/detail/type_mat3x4.inl @@ -0,0 +1,578 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0, 0);
+ this->value[1] = col_type(0, 1, 0, 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0, 0, 0);
+ this->value[1] = col_type(0, s, 0, 0);
+ this->value[2] = col_type(0, 0, s, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+ (
+ T x0, T y0, T z0, T w0,
+ T x1, T y1, T z1, T w1,
+ T x2, T y2, T z2, T w2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{
+ col_type(x0, y0, z0, w0),
+ col_type(x1, y1, z1, w1),
+ col_type(x2, y2, z2, w2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0, w0);
+ this->value[1] = col_type(x1, y1, z1, w1);
+ this->value[2] = col_type(x2, y2, z2, w2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+ this->value[2] = v2;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X0, typename Y0, typename Z0, typename W0,
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
+ (
+ X0 x0, Y0 y0, Z0 z0, W0 w0,
+ X1 x1, Y1 y1, Z1 z1, W1 w1,
+ X2 x2, Y2 y2, Z2 z2, W2 w2
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{
+ col_type(x0, y0, z0, w0),
+ col_type(x1, y1, z1, w1),
+ col_type(x2, y2, z2, w2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0, w0);
+ this->value[1] = col_type(x1, y1, z1, w1);
+ this->value[2] = col_type(x2, y2, z2, w2);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2, typename V3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v0);
+ this->value[1] = col_type(v1);
+ this->value[2] = col_type(v2);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(m[2], 1, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0, 0, 1, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(m[2], 1, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 0);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type & mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 4, T, Q>::col_type const& mat<3, 4, T, Q>::operator[](typename mat<3, 4, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator=(mat<3, 4, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator+=(mat<3, 4, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator-=(mat<3, 4, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> & mat<3, 4, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q>& mat<3, 4, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator++(int)
+ {
+ mat<3, 4, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> mat<3, 4, T, Q>::operator--(int)
+ {
+ mat<3, 4, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m)
+ {
+ return mat<3, 4, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m, T scalar)
+ {
+ return mat<3, 4, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar,
+ m[2] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator+(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return mat<3, 4, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m, T scalar)
+ {
+ return mat<3, 4, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar,
+ m[2] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator-(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return mat<3, 4, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m, T scalar)
+ {
+ return mat<3, 4, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(T scalar, mat<3, 4, T, Q> const& m)
+ {
+ return mat<3, 4, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::col_type operator*
+ (
+ mat<3, 4, T, Q> const& m,
+ typename mat<3, 4, T, Q>::row_type const& v
+ )
+ {
+ return typename mat<3, 4, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+ m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+ m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
+ m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<3, 4, T, Q>::row_type operator*
+ (
+ typename mat<3, 4, T, Q>::col_type const& v,
+ mat<3, 4, T, Q> const& m
+ )
+ {
+ return typename mat<3, 4, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+ v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
+ v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ const T SrcA00 = m1[0][0];
+ const T SrcA01 = m1[0][1];
+ const T SrcA02 = m1[0][2];
+ const T SrcA03 = m1[0][3];
+ const T SrcA10 = m1[1][0];
+ const T SrcA11 = m1[1][1];
+ const T SrcA12 = m1[1][2];
+ const T SrcA13 = m1[1][3];
+ const T SrcA20 = m1[2][0];
+ const T SrcA21 = m1[2][1];
+ const T SrcA22 = m1[2][2];
+ const T SrcA23 = m1[2][3];
+
+ const T SrcB00 = m2[0][0];
+ const T SrcB01 = m2[0][1];
+ const T SrcB02 = m2[0][2];
+ const T SrcB10 = m2[1][0];
+ const T SrcB11 = m2[1][1];
+ const T SrcB12 = m2[1][2];
+ const T SrcB20 = m2[2][0];
+ const T SrcB21 = m2[2][1];
+ const T SrcB22 = m2[2][2];
+ const T SrcB30 = m2[3][0];
+ const T SrcB31 = m2[3][1];
+ const T SrcB32 = m2[3][2];
+
+ mat<4, 4, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+ Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+ Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+ Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+ Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
+ Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+ Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+ Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+ Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
+ Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
+ Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
+ Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
+ Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<2, 3, T, Q> const& m2)
+ {
+ return mat<2, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<3, 4, T, Q> const& m1, mat<3, 3, T, Q> const& m2)
+ {
+ return mat<3, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
+ m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(mat<3, 4, T, Q> const& m, T scalar)
+ {
+ return mat<3, 4, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar,
+ m[2] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator/(T scalar, mat<3, 4, T, Q> const& m)
+ {
+ return mat<3, 4, T, Q>(
+ scalar / m[0],
+ scalar / m[1],
+ scalar / m[2]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat4x2.hpp b/src/include/glm/detail/type_mat4x2.hpp new file mode 100644 index 0000000..eb276ab --- /dev/null +++ b/src/include/glm/detail/type_mat4x2.hpp @@ -0,0 +1,171 @@ +/// @ref core
+/// @file glm/detail/type_mat4x2.hpp
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<4, 2, T, Q>
+ {
+ typedef vec<2, T, Q> col_type;
+ typedef vec<4, T, Q> row_type;
+ typedef mat<4, 2, T, Q> type;
+ typedef mat<2, 4, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[4];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 2, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T x0, T y0,
+ T x1, T y1,
+ T x2, T y2,
+ T x3, T y3);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2,
+ col_type const& v3);
+
+ // -- Conversions --
+
+ template<
+ typename X0, typename Y0,
+ typename X1, typename Y1,
+ typename X2, typename Y2,
+ typename X3, typename Y3>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X0 x0, Y0 y0,
+ X1 x1, Y1 y1,
+ X2 x2, Y2 y2,
+ X3 x3, Y3 y3);
+
+ template<typename V1, typename V2, typename V3, typename V4>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<2, V1, Q> const& v1,
+ vec<2, V2, Q> const& v2,
+ vec<2, V3, Q> const& v3,
+ vec<2, V4, Q> const& v4);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator++ ();
+ GLM_FUNC_DECL mat<4, 2, T, Q> & operator-- ();
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x2.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat4x2.inl b/src/include/glm/detail/type_mat4x2.inl new file mode 100644 index 0000000..67890e5 --- /dev/null +++ b/src/include/glm/detail/type_mat4x2.inl @@ -0,0 +1,574 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0);
+ this->value[1] = col_type(0, 1);
+ this->value[2] = col_type(0, 0);
+ this->value[3] = col_type(0, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(T s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0);
+ this->value[1] = col_type(0, s);
+ this->value[2] = col_type(0, 0);
+ this->value[3] = col_type(0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+ (
+ T x0, T y0,
+ T x1, T y1,
+ T x2, T y2,
+ T x3, T y3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0);
+ this->value[1] = col_type(x1, y1);
+ this->value[2] = col_type(x2, y2);
+ this->value[3] = col_type(x3, y3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+ this->value[2] = v2;
+ this->value[3] = v3;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X0, typename Y0,
+ typename X1, typename Y1,
+ typename X2, typename Y2,
+ typename X3, typename Y3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
+ (
+ X0 x0, Y0 y0,
+ X1 x1, Y1 y1,
+ X2 x2, Y2 y2,
+ X3 x3, Y3 y3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0);
+ this->value[1] = col_type(x1, y1);
+ this->value[2] = col_type(x2, y2);
+ this->value[3] = col_type(x3, y3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V0, typename V1, typename V2, typename V3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v0);
+ this->value[1] = col_type(v1);
+ this->value[2] = col_type(v2);
+ this->value[3] = col_type(v3);
+# endif
+ }
+
+ // -- Conversion --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type & mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 2, T, Q>::col_type const& mat<4, 2, T, Q>::operator[](typename mat<4, 2, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q>& mat<4, 2, T, Q>::operator=(mat<4, 2, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ this->value[3] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator+=(mat<4, 2, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ this->value[3] += m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ this->value[3] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator-=(mat<4, 2, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ this->value[3] -= m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ this->value[3] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ this->value[3] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ ++this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> & mat<4, 2, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ --this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator++(int)
+ {
+ mat<4, 2, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> mat<4, 2, T, Q>::operator--(int)
+ {
+ mat<4, 2, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m)
+ {
+ return mat<4, 2, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2],
+ -m[3]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m, T scalar)
+ {
+ return mat<4, 2, T, Q>(
+ m[0] + scalar,
+ m[1] + scalar,
+ m[2] + scalar,
+ m[3] + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator+(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return mat<4, 2, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2],
+ m1[3] + m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m, T scalar)
+ {
+ return mat<4, 2, T, Q>(
+ m[0] - scalar,
+ m[1] - scalar,
+ m[2] - scalar,
+ m[3] - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator-(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return mat<4, 2, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2],
+ m1[3] - m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m, T scalar)
+ {
+ return mat<4, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar,
+ m[3] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(T scalar, mat<4, 2, T, Q> const& m)
+ {
+ return mat<4, 2, T, Q>(
+ m[0] * scalar,
+ m[1] * scalar,
+ m[2] * scalar,
+ m[3] * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::col_type operator*(mat<4, 2, T, Q> const& m, typename mat<4, 2, T, Q>::row_type const& v)
+ {
+ return typename mat<4, 2, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+ m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 2, T, Q>::row_type operator*(typename mat<4, 2, T, Q>::col_type const& v, mat<4, 2, T, Q> const& m)
+ {
+ return typename mat<4, 2, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1],
+ v.x * m[1][0] + v.y * m[1][1],
+ v.x * m[2][0] + v.y * m[2][1],
+ v.x * m[3][0] + v.y * m[3][1]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ T const SrcA00 = m1[0][0];
+ T const SrcA01 = m1[0][1];
+ T const SrcA10 = m1[1][0];
+ T const SrcA11 = m1[1][1];
+ T const SrcA20 = m1[2][0];
+ T const SrcA21 = m1[2][1];
+ T const SrcA30 = m1[3][0];
+ T const SrcA31 = m1[3][1];
+
+ T const SrcB00 = m2[0][0];
+ T const SrcB01 = m2[0][1];
+ T const SrcB02 = m2[0][2];
+ T const SrcB03 = m2[0][3];
+ T const SrcB10 = m2[1][0];
+ T const SrcB11 = m2[1][1];
+ T const SrcB12 = m2[1][2];
+ T const SrcB13 = m2[1][3];
+
+ mat<2, 2, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return mat<3, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator*(mat<4, 2, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return mat<4, 2, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(mat<4, 2, T, Q> const& m, T scalar)
+ {
+ return mat<4, 2, T, Q>(
+ m[0] / scalar,
+ m[1] / scalar,
+ m[2] / scalar,
+ m[3] / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 2, T, Q> operator/(T scalar, mat<4, 2, T, Q> const& m)
+ {
+ return mat<4, 2, T, Q>(
+ scalar / m[0],
+ scalar / m[1],
+ scalar / m[2],
+ scalar / m[3]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, Q> const& m1, mat<4, 2, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat4x3.hpp b/src/include/glm/detail/type_mat4x3.hpp new file mode 100644 index 0000000..a7a591f --- /dev/null +++ b/src/include/glm/detail/type_mat4x3.hpp @@ -0,0 +1,171 @@ +/// @ref core
+/// @file glm/detail/type_mat4x3.hpp
+
+#pragma once
+
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<4, 3, T, Q>
+ {
+ typedef vec<3, T, Q> col_type;
+ typedef vec<4, T, Q> row_type;
+ typedef mat<4, 3, T, Q> type;
+ typedef mat<3, 4, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[4];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 3, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T const& x0, T const& y0, T const& z0,
+ T const& x1, T const& y1, T const& z1,
+ T const& x2, T const& y2, T const& z2,
+ T const& x3, T const& y3, T const& z3);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2,
+ col_type const& v3);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1, typename Z1,
+ typename X2, typename Y2, typename Z2,
+ typename X3, typename Y3, typename Z3,
+ typename X4, typename Y4, typename Z4>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 const& x1, Y1 const& y1, Z1 const& z1,
+ X2 const& x2, Y2 const& y2, Z2 const& z2,
+ X3 const& x3, Y3 const& y3, Z3 const& z3,
+ X4 const& x4, Y4 const& y4, Z4 const& z4);
+
+ template<typename V1, typename V2, typename V3, typename V4>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<3, V1, Q> const& v1,
+ vec<3, V2, Q> const& v2,
+ vec<3, V3, Q> const& v3,
+ vec<3, V4, Q> const& v4);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 3, T, Q> & operator/=(U s);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<4, 3, T, Q>& operator++();
+ GLM_FUNC_DECL mat<4, 3, T, Q>& operator--();
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 3, T, Q>::col_type operator*(mat<4, 3, T, Q> const& m, typename mat<4, 3, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 3, T, Q>::row_type operator*(typename mat<4, 3, T, Q>::col_type const& v, mat<4, 3, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x3.inl"
+#endif //GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_mat4x3.inl b/src/include/glm/detail/type_mat4x3.inl new file mode 100644 index 0000000..a43030a --- /dev/null +++ b/src/include/glm/detail/type_mat4x3.inl @@ -0,0 +1,598 @@ +namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0);
+ this->value[1] = col_type(0, 1, 0);
+ this->value[2] = col_type(0, 0, 1);
+ this->value[3] = col_type(0, 0, 0);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T const& s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0, 0);
+ this->value[1] = col_type(0, s, 0);
+ this->value[2] = col_type(0, 0, s);
+ this->value[3] = col_type(0, 0, 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+ (
+ T const& x0, T const& y0, T const& z0,
+ T const& x1, T const& y1, T const& z1,
+ T const& x2, T const& y2, T const& z2,
+ T const& x3, T const& y3, T const& z3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0);
+ this->value[1] = col_type(x1, y1, z1);
+ this->value[2] = col_type(x2, y2, z2);
+ this->value[3] = col_type(x3, y3, z3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+ this->value[2] = v2;
+ this->value[3] = v3;
+# endif
+ }
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X0, typename Y0, typename Z0,
+ typename X1, typename Y1, typename Z1,
+ typename X2, typename Y2, typename Z2,
+ typename X3, typename Y3, typename Z3>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
+ (
+ X0 const& x0, Y0 const& y0, Z0 const& z0,
+ X1 const& x1, Y1 const& y1, Z1 const& z1,
+ X2 const& x2, Y2 const& y2, Z2 const& z2,
+ X3 const& x3, Y3 const& y3, Z3 const& z3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0);
+ this->value[1] = col_type(x1, y1, z1);
+ this->value[2] = col_type(x2, y2, z2);
+ this->value[3] = col_type(x3, y3, z3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2, typename V3, typename V4>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+ this->value[2] = col_type(v3);
+ this->value[3] = col_type(v4);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(0, 0, 1);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0, 0, 1);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 1);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(0, 0, 1);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(m[3], 0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 1);
+ this->value[3] = col_type(m[3], 0);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(0);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type & mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 3, T, Q>::col_type const& mat<4, 3, T, Q>::operator[](typename mat<4, 3, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary updatable operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q>& mat<4, 3, T, Q>::operator=(mat<4, 3, U, Q> const& m)
+ {
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ this->value[3] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator+=(mat<4, 3, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ this->value[3] += m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ this->value[3] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator-=(mat<4, 3, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ this->value[3] -= m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ this->value[3] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ this->value[3] /= s;
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ ++this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> & mat<4, 3, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ --this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator++(int)
+ {
+ mat<4, 3, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> mat<4, 3, T, Q>::operator--(int)
+ {
+ mat<4, 3, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m)
+ {
+ return mat<4, 3, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2],
+ -m[3]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m, T const& s)
+ {
+ return mat<4, 3, T, Q>(
+ m[0] + s,
+ m[1] + s,
+ m[2] + s,
+ m[3] + s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator+(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return mat<4, 3, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2],
+ m1[3] + m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m, T const& s)
+ {
+ return mat<4, 3, T, Q>(
+ m[0] - s,
+ m[1] - s,
+ m[2] - s,
+ m[3] - s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator-(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return mat<4, 3, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2],
+ m1[3] - m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m, T const& s)
+ {
+ return mat<4, 3, T, Q>(
+ m[0] * s,
+ m[1] * s,
+ m[2] * s,
+ m[3] * s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(T const& s, mat<4, 3, T, Q> const& m)
+ {
+ return mat<4, 3, T, Q>(
+ m[0] * s,
+ m[1] * s,
+ m[2] * s,
+ m[3] * s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::col_type operator*
+ (
+ mat<4, 3, T, Q> const& m,
+ typename mat<4, 3, T, Q>::row_type const& v)
+ {
+ return typename mat<4, 3, T, Q>::col_type(
+ m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+ m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
+ m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 3, T, Q>::row_type operator*
+ (
+ typename mat<4, 3, T, Q>::col_type const& v,
+ mat<4, 3, T, Q> const& m)
+ {
+ return typename mat<4, 3, T, Q>::row_type(
+ v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+ v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
+ v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
+ v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return mat<2, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ T const SrcA00 = m1[0][0];
+ T const SrcA01 = m1[0][1];
+ T const SrcA02 = m1[0][2];
+ T const SrcA10 = m1[1][0];
+ T const SrcA11 = m1[1][1];
+ T const SrcA12 = m1[1][2];
+ T const SrcA20 = m1[2][0];
+ T const SrcA21 = m1[2][1];
+ T const SrcA22 = m1[2][2];
+ T const SrcA30 = m1[3][0];
+ T const SrcA31 = m1[3][1];
+ T const SrcA32 = m1[3][2];
+
+ T const SrcB00 = m2[0][0];
+ T const SrcB01 = m2[0][1];
+ T const SrcB02 = m2[0][2];
+ T const SrcB03 = m2[0][3];
+ T const SrcB10 = m2[1][0];
+ T const SrcB11 = m2[1][1];
+ T const SrcB12 = m2[1][2];
+ T const SrcB13 = m2[1][3];
+ T const SrcB20 = m2[2][0];
+ T const SrcB21 = m2[2][1];
+ T const SrcB22 = m2[2][2];
+ T const SrcB23 = m2[2][3];
+
+ mat<3, 3, T, Q> Result;
+ Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+ Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+ Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
+ Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+ Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+ Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
+ Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
+ Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
+ Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator*(mat<4, 3, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return mat<4, 3, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+ m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
+ m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
+ m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(mat<4, 3, T, Q> const& m, T const& s)
+ {
+ return mat<4, 3, T, Q>(
+ m[0] / s,
+ m[1] / s,
+ m[2] / s,
+ m[3] / s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 3, T, Q> operator/(T const& s, mat<4, 3, T, Q> const& m)
+ {
+ return mat<4, 3, T, Q>(
+ s / m[0],
+ s / m[1],
+ s / m[2],
+ s / m[3]);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, Q> const& m1, mat<4, 3, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+ }
+} //namespace glm
diff --git a/src/include/glm/detail/type_mat4x4.hpp b/src/include/glm/detail/type_mat4x4.hpp new file mode 100644 index 0000000..fb41dbb --- /dev/null +++ b/src/include/glm/detail/type_mat4x4.hpp @@ -0,0 +1,189 @@ +/// @ref core
+/// @file glm/detail/type_mat4x4.hpp
+
+#pragma once
+
+#include "type_vec4.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct mat<4, 4, T, Q>
+ {
+ typedef vec<4, T, Q> col_type;
+ typedef vec<4, T, Q> row_type;
+ typedef mat<4, 4, T, Q> type;
+ typedef mat<4, 4, T, Q> transpose_type;
+ typedef T value_type;
+
+ private:
+ col_type value[4];
+
+ public:
+ // -- Accesses --
+
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+ GLM_FUNC_DECL col_type & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const;
+
+ // -- Constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR mat() GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(mat<4, 4, T, P> const& m);
+
+ GLM_FUNC_DECL explicit GLM_CONSTEXPR mat(T const& x);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ T const& x0, T const& y0, T const& z0, T const& w0,
+ T const& x1, T const& y1, T const& z1, T const& w1,
+ T const& x2, T const& y2, T const& z2, T const& w2,
+ T const& x3, T const& y3, T const& z3, T const& w3);
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ col_type const& v0,
+ col_type const& v1,
+ col_type const& v2,
+ col_type const& v3);
+
+ // -- Conversions --
+
+ template<
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2,
+ typename X3, typename Y3, typename Z3, typename W3,
+ typename X4, typename Y4, typename Z4, typename W4>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+ X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+ X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+ X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4);
+
+ template<typename V1, typename V2, typename V3, typename V4>
+ GLM_FUNC_DECL GLM_CONSTEXPR mat(
+ vec<4, V1, Q> const& v1,
+ vec<4, V2, Q> const& v2,
+ vec<4, V3, Q> const& v3,
+ vec<4, V4, Q> const& v4);
+
+ // -- Matrix conversions --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 4, U, P> const& m);
+
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 3, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<2, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 2, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<3, 4, T, Q> const& x);
+ GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR mat(mat<4, 3, T, Q> const& x);
+
+ // -- Unary arithmetic operators --
+
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(U s);
+ template<typename U>
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator++();
+ GLM_FUNC_DECL mat<4, 4, T, Q> & operator--();
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator++(int);
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator--(int);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator*(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator*(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_mat4x4.inl b/src/include/glm/detail/type_mat4x4.inl new file mode 100644 index 0000000..e91d5cb --- /dev/null +++ b/src/include/glm/detail/type_mat4x4.inl @@ -0,0 +1,706 @@ +#include "../matrix.hpp"
+
+namespace glm
+{
+ // -- Constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat()
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
+ : value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
+ this->value[0] = col_type(1, 0, 0, 0);
+ this->value[1] = col_type(0, 1, 0, 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(T const& s)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(s, 0, 0, 0);
+ this->value[1] = col_type(0, s, 0, 0);
+ this->value[2] = col_type(0, 0, s, 0);
+ this->value[3] = col_type(0, 0, 0, s);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+ (
+ T const& x0, T const& y0, T const& z0, T const& w0,
+ T const& x1, T const& y1, T const& z1, T const& w1,
+ T const& x2, T const& y2, T const& z2, T const& w2,
+ T const& x3, T const& y3, T const& z3, T const& w3
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{
+ col_type(x0, y0, z0, w0),
+ col_type(x1, y1, z1, w1),
+ col_type(x2, y2, z2, w2),
+ col_type(x3, y3, z3, w3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x0, y0, z0, w0);
+ this->value[1] = col_type(x1, y1, z1, w1);
+ this->value[2] = col_type(x2, y2, z2, w2);
+ this->value[3] = col_type(x3, y3, z3, w3);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = v0;
+ this->value[1] = v1;
+ this->value[2] = v2;
+ this->value[3] = v3;
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0]);
+ this->value[1] = col_type(m[1]);
+ this->value[2] = col_type(m[2]);
+ this->value[3] = col_type(m[3]);
+# endif
+ }
+
+ // -- Conversions --
+
+ template<typename T, qualifier Q>
+ template<
+ typename X1, typename Y1, typename Z1, typename W1,
+ typename X2, typename Y2, typename Z2, typename W2,
+ typename X3, typename Y3, typename Z3, typename W3,
+ typename X4, typename Y4, typename Z4, typename W4>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
+ (
+ X1 const& x1, Y1 const& y1, Z1 const& z1, W1 const& w1,
+ X2 const& x2, Y2 const& y2, Z2 const& z2, W2 const& w2,
+ X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
+ X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4
+ )
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)}
+# endif
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<X1>::is_iec559 || std::numeric_limits<X1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Y1>::is_iec559 || std::numeric_limits<Y1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Z1>::is_iec559 || std::numeric_limits<Z1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<W1>::is_iec559 || std::numeric_limits<W1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+ GLM_STATIC_ASSERT(std::numeric_limits<X2>::is_iec559 || std::numeric_limits<X2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Y2>::is_iec559 || std::numeric_limits<Y2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Z2>::is_iec559 || std::numeric_limits<Z2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<W2>::is_iec559 || std::numeric_limits<W2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
+
+ GLM_STATIC_ASSERT(std::numeric_limits<X3>::is_iec559 || std::numeric_limits<X3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Y3>::is_iec559 || std::numeric_limits<Y3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Z3>::is_iec559 || std::numeric_limits<Z3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<W3>::is_iec559 || std::numeric_limits<W3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
+
+ GLM_STATIC_ASSERT(std::numeric_limits<X4>::is_iec559 || std::numeric_limits<X4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Y4>::is_iec559 || std::numeric_limits<Y4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<Z4>::is_iec559 || std::numeric_limits<Z4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<W4>::is_iec559 || std::numeric_limits<W4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
+
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(x1, y1, z1, w1);
+ this->value[1] = col_type(x2, y2, z2, w2);
+ this->value[2] = col_type(x3, y3, z3, w3);
+ this->value[3] = col_type(x4, y4, z4, w4);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ template<typename V1, typename V2, typename V3, typename V4>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+# endif
+ {
+ GLM_STATIC_ASSERT(std::numeric_limits<V1>::is_iec559 || std::numeric_limits<V1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<V2>::is_iec559 || std::numeric_limits<V2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<V3>::is_iec559 || std::numeric_limits<V3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
+ GLM_STATIC_ASSERT(std::numeric_limits<V4>::is_iec559 || std::numeric_limits<V4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
+
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(v1);
+ this->value[1] = col_type(v2);
+ this->value[2] = col_type(v3);
+ this->value[3] = col_type(v4);
+# endif
+ }
+
+ // -- Matrix conversions --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(m[2], 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = col_type(0, 0, 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0, 0);
+ this->value[1] = col_type(m[1], 0, 0);
+ this->value[2] = col_type(0, 0, 1, 0);
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = col_type(0, 0, 0, 1);
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
+# if GLM_HAS_INITIALIZER_LISTS
+ : value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)}
+# endif
+ {
+# if !GLM_HAS_INITIALIZER_LISTS
+ this->value[0] = col_type(m[0], 0);
+ this->value[1] = col_type(m[1], 0);
+ this->value[2] = col_type(m[2], 0);
+ this->value[3] = col_type(m[3], 1);
+# endif
+ }
+
+ // -- Accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type & mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i)
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::col_type const& mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) const
+ {
+ assert(i < this->length());
+ return this->value[i];
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator=(mat<4, 4, U, Q> const& m)
+ {
+ //memcpy could be faster
+ //memcpy(&this->value, &m.value, 16 * sizeof(valType));
+ this->value[0] = m[0];
+ this->value[1] = m[1];
+ this->value[2] = m[2];
+ this->value[3] = m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(U s)
+ {
+ this->value[0] += s;
+ this->value[1] += s;
+ this->value[2] += s;
+ this->value[3] += s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q>& mat<4, 4, T, Q>::operator+=(mat<4, 4, U, Q> const& m)
+ {
+ this->value[0] += m[0];
+ this->value[1] += m[1];
+ this->value[2] += m[2];
+ this->value[3] += m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(U s)
+ {
+ this->value[0] -= s;
+ this->value[1] -= s;
+ this->value[2] -= s;
+ this->value[3] -= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator-=(mat<4, 4, U, Q> const& m)
+ {
+ this->value[0] -= m[0];
+ this->value[1] -= m[1];
+ this->value[2] -= m[2];
+ this->value[3] -= m[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(U s)
+ {
+ this->value[0] *= s;
+ this->value[1] *= s;
+ this->value[2] *= s;
+ this->value[3] *= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator*=(mat<4, 4, U, Q> const& m)
+ {
+ return (*this = *this * m);
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(U s)
+ {
+ this->value[0] /= s;
+ this->value[1] /= s;
+ this->value[2] /= s;
+ this->value[3] /= s;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator/=(mat<4, 4, U, Q> const& m)
+ {
+ return *this *= inverse(m);
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator++()
+ {
+ ++this->value[0];
+ ++this->value[1];
+ ++this->value[2];
+ ++this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> & mat<4, 4, T, Q>::operator--()
+ {
+ --this->value[0];
+ --this->value[1];
+ --this->value[2];
+ --this->value[3];
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator++(int)
+ {
+ mat<4, 4, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> mat<4, 4, T, Q>::operator--(int)
+ {
+ mat<4, 4, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary constant operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m)
+ {
+ return m;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m)
+ {
+ return mat<4, 4, T, Q>(
+ -m[0],
+ -m[1],
+ -m[2],
+ -m[3]);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m, T const& s)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] + s,
+ m[1] + s,
+ m[2] + s,
+ m[3] + s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(T const& s, mat<4, 4, T, Q> const& m)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] + s,
+ m[1] + s,
+ m[2] + s,
+ m[3] + s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator+(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return mat<4, 4, T, Q>(
+ m1[0] + m2[0],
+ m1[1] + m2[1],
+ m1[2] + m2[2],
+ m1[3] + m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m, T const& s)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] - s,
+ m[1] - s,
+ m[2] - s,
+ m[3] - s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(T const& s, mat<4, 4, T, Q> const& m)
+ {
+ return mat<4, 4, T, Q>(
+ s - m[0],
+ s - m[1],
+ s - m[2],
+ s - m[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator-(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return mat<4, 4, T, Q>(
+ m1[0] - m2[0],
+ m1[1] - m2[1],
+ m1[2] - m2[2],
+ m1[3] - m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m, T const & s)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] * s,
+ m[1] * s,
+ m[2] * s,
+ m[3] * s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(T const& s, mat<4, 4, T, Q> const& m)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] * s,
+ m[1] * s,
+ m[2] * s,
+ m[3] * s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator*
+ (
+ mat<4, 4, T, Q> const& m,
+ typename mat<4, 4, T, Q>::row_type const& v
+ )
+ {
+/*
+ __m128 v0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(0, 0, 0, 0));
+ __m128 v1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(1, 1, 1, 1));
+ __m128 v2 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(2, 2, 2, 2));
+ __m128 v3 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 3, 3, 3));
+
+ __m128 m0 = _mm_mul_ps(m[0].data, v0);
+ __m128 m1 = _mm_mul_ps(m[1].data, v1);
+ __m128 a0 = _mm_add_ps(m0, m1);
+
+ __m128 m2 = _mm_mul_ps(m[2].data, v2);
+ __m128 m3 = _mm_mul_ps(m[3].data, v3);
+ __m128 a1 = _mm_add_ps(m2, m3);
+
+ __m128 a2 = _mm_add_ps(a0, a1);
+
+ return typename mat<4, 4, T, Q>::col_type(a2);
+*/
+
+ typename mat<4, 4, T, Q>::col_type const Mov0(v[0]);
+ typename mat<4, 4, T, Q>::col_type const Mov1(v[1]);
+ typename mat<4, 4, T, Q>::col_type const Mul0 = m[0] * Mov0;
+ typename mat<4, 4, T, Q>::col_type const Mul1 = m[1] * Mov1;
+ typename mat<4, 4, T, Q>::col_type const Add0 = Mul0 + Mul1;
+ typename mat<4, 4, T, Q>::col_type const Mov2(v[2]);
+ typename mat<4, 4, T, Q>::col_type const Mov3(v[3]);
+ typename mat<4, 4, T, Q>::col_type const Mul2 = m[2] * Mov2;
+ typename mat<4, 4, T, Q>::col_type const Mul3 = m[3] * Mov3;
+ typename mat<4, 4, T, Q>::col_type const Add1 = Mul2 + Mul3;
+ typename mat<4, 4, T, Q>::col_type const Add2 = Add0 + Add1;
+ return Add2;
+
+/*
+ return typename mat<4, 4, T, Q>::col_type(
+ m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0] * v[3],
+ m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1] * v[3],
+ m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2] * v[3],
+ m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3] * v[3]);
+*/
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator*
+ (
+ typename mat<4, 4, T, Q>::col_type const& v,
+ mat<4, 4, T, Q> const& m
+ )
+ {
+ return typename mat<4, 4, T, Q>::row_type(
+ m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3],
+ m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3],
+ m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3],
+ m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<2, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<2, 4, T, Q> const& m2)
+ {
+ return mat<2, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<3, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<3, 4, T, Q> const& m2)
+ {
+ return mat<3, 4, T, Q>(
+ m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
+ m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
+ m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
+ m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
+ m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
+ m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
+ m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
+ m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
+ m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
+ m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
+ m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
+ m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0];
+ typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1];
+ typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2];
+ typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3];
+
+ typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0];
+ typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1];
+ typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2];
+ typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3];
+
+ mat<4, 4, T, Q> Result;
+ Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
+ Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
+ Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
+ Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m, T const& s)
+ {
+ return mat<4, 4, T, Q>(
+ m[0] / s,
+ m[1] / s,
+ m[2] / s,
+ m[3] / s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(T const& s, mat<4, 4, T, Q> const& m)
+ {
+ return mat<4, 4, T, Q>(
+ s / m[0],
+ s / m[1],
+ s / m[2],
+ s / m[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::col_type operator/(mat<4, 4, T, Q> const& m, typename mat<4, 4, T, Q>::row_type const& v)
+ {
+ return inverse(m) * v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER typename mat<4, 4, T, Q>::row_type operator/(typename mat<4, 4, T, Q>::col_type const& v, mat<4, 4, T, Q> const& m)
+ {
+ return v * inverse(m);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER mat<4, 4, T, Q> operator/(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ mat<4, 4, T, Q> m1_copy(m1);
+ return m1_copy /= m2;
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, Q> const& m1, mat<4, 4, T, Q> const& m2)
+ {
+ return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "type_mat4x4_simd.inl"
+#endif
diff --git a/src/include/glm/detail/type_mat4x4_simd.inl b/src/include/glm/detail/type_mat4x4_simd.inl new file mode 100644 index 0000000..c4ba072 --- /dev/null +++ b/src/include/glm/detail/type_mat4x4_simd.inl @@ -0,0 +1,6 @@ +/// @ref core
+
+namespace glm
+{
+
+}//namespace glm
diff --git a/src/include/glm/detail/type_quat.hpp b/src/include/glm/detail/type_quat.hpp new file mode 100644 index 0000000..47fae4b --- /dev/null +++ b/src/include/glm/detail/type_quat.hpp @@ -0,0 +1,186 @@ +/// @ref core
+/// @file glm/detail/type_quat.hpp
+
+#pragma once
+
+// Dependency:
+#include "../detail/type_mat3x3.hpp"
+#include "../detail/type_mat4x4.hpp"
+#include "../detail/type_vec3.hpp"
+#include "../detail/type_vec4.hpp"
+#include "../ext/vector_relational.hpp"
+#include "../ext/quaternion_relational.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct qua
+ {
+ // -- Implementation detail --
+
+ typedef qua<T, Q> type;
+ typedef T value_type;
+
+ // -- Data --
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+# pragma clang diagnostic ignored "-Wnested-anon-types"
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+# endif
+# endif
+
+# if GLM_LANG & GLM_LANG_CXXMS_FLAG
+ union
+ {
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ struct { T w, x, y, z; };
+# else
+ struct { T x, y, z, w; };
+# endif
+
+ typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+ };
+# else
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ T w, x, y, z;
+# else
+ T x, y, z, w;
+# endif
+# endif
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+# endif
+
+ // -- Component accesses --
+
+ typedef length_t length_type;
+
+ /// Return the count of components of a quaternion
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+ GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+ // -- Implicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR qua() GLM_DEFAULT;
+ GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, Q> const& q) GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua(qua<T, P> const& q);
+
+ // -- Explicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR qua(T s, vec<3, T, Q> const& v);
+ GLM_FUNC_DECL GLM_CONSTEXPR qua(T w, T x, T y, T z);
+
+ // -- Conversion constructors --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(qua<U, P> const& q);
+
+ /// Explicit conversion operators
+# if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+ GLM_FUNC_DECL explicit operator mat<3, 3, T, Q>() const;
+ GLM_FUNC_DECL explicit operator mat<4, 4, T, Q>() const;
+# endif
+
+ /// Create a quaternion from two normalized axis
+ ///
+ /// @param u A first normalized axis
+ /// @param v A second normalized axis
+ /// @see gtc_quaternion
+ /// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
+ GLM_FUNC_DECL qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v);
+
+ /// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT qua(vec<3, T, Q> const& eulerAngles);
+ GLM_FUNC_DECL GLM_EXPLICIT qua(mat<3, 3, T, Q> const& q);
+ GLM_FUNC_DECL GLM_EXPLICIT qua(mat<4, 4, T, Q> const& q);
+
+ // -- Unary arithmetic operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<T, Q> const& q) GLM_DEFAULT;
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<U, Q> const& q);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator+=(qua<U, Q> const& q);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator-=(qua<U, Q> const& q);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator*=(qua<U, Q> const& q);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator*=(U s);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator/=(U s);
+ };
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, T const& s);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator*(T const& s, qua<T, Q> const& q);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> operator/(qua<T, Q> const& q, T const& s);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_quat.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_quat.inl b/src/include/glm/detail/type_quat.inl new file mode 100644 index 0000000..f2b5a28 --- /dev/null +++ b/src/include/glm/detail/type_quat.inl @@ -0,0 +1,408 @@ +#include "../trigonometric.hpp"
+#include "../exponential.hpp"
+#include "../ext/quaternion_geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+ template <typename T>
+ struct genTypeTrait<qua<T> >
+ {
+ static const genTypeEnum GENTYPE = GENTYPE_QUAT;
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_dot<qua<T, Q>, T, Aligned>
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(qua<T, Q> const& a, qua<T, Q> const& b)
+ {
+ vec<4, T, Q> tmp(a.w * b.w, a.x * b.x, a.y * b.y, a.z * b.z);
+ return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_quat_add
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+ {
+ return qua<T, Q>(q.w + p.w, q.x + p.x, q.y + p.y, q.z + p.z);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_quat_sub
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, qua<T, Q> const& p)
+ {
+ return qua<T, Q>(q.w - p.w, q.x - p.x, q.y - p.y, q.z - p.z);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_quat_mul_scalar
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, T s)
+ {
+ return qua<T, Q>(q.w * s, q.x * s, q.y * s, q.z * s);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_quat_div_scalar
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static qua<T, Q> call(qua<T, Q> const& q, T s)
+ {
+ return qua<T, Q>(q.w / s, q.x / s, q.y / s, q.z / s);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_quat_mul_vec4
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(qua<T, Q> const& q, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(q * vec<3, T, Q>(v), v.w);
+ }
+ };
+}//namespace detail
+
+ // -- Component accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & qua<T, Q>::operator[](typename qua<T, Q>::length_type i)
+ {
+ assert(i >= 0 && i < this->length());
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ return (&w)[i];
+# else
+ return (&x)[i];
+# endif
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& qua<T, Q>::operator[](typename qua<T, Q>::length_type i) const
+ {
+ assert(i >= 0 && i < this->length());
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ return (&w)[i];
+# else
+ return (&x)[i];
+# endif
+ }
+
+ // -- Implicit basic constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua()
+# if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(1), x(0), y(0), z(0)
+# else
+ : x(0), y(0), z(0), w(1)
+# endif
+# endif
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, Q> const& q)
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(q.w), x(q.x), y(q.y), z(q.z)
+# else
+ : x(q.x), y(q.y), z(q.z), w(q.w)
+# endif
+ {}
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, P> const& q)
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(q.w), x(q.x), y(q.y), z(q.z)
+# else
+ : x(q.x), y(q.y), z(q.z), w(q.w)
+# endif
+ {}
+
+ // -- Explicit basic constructors --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T s, vec<3, T, Q> const& v)
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(s), x(v.x), y(v.y), z(v.z)
+# else
+ : x(v.x), y(v.y), z(v.z), w(s)
+# endif
+ {}
+
+ template <typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(T _w, T _x, T _y, T _z)
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(_w), x(_x), y(_y), z(_z)
+# else
+ : x(_x), y(_y), z(_z), w(_w)
+# endif
+ {}
+
+ // -- Conversion constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<U, P> const& q)
+# ifdef GLM_FORCE_QUAT_DATA_WXYZ
+ : w(static_cast<T>(q.w)), x(static_cast<T>(q.x)), y(static_cast<T>(q.y)), z(static_cast<T>(q.z))
+# else
+ : x(static_cast<T>(q.x)), y(static_cast<T>(q.y)), z(static_cast<T>(q.z)), w(static_cast<T>(q.w))
+# endif
+ {}
+
+ //template<typename valType>
+ //GLM_FUNC_QUALIFIER qua<valType>::qua
+ //(
+ // valType const& pitch,
+ // valType const& yaw,
+ // valType const& roll
+ //)
+ //{
+ // vec<3, valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
+ // vec<3, valType> c = glm::cos(eulerAngle * valType(0.5));
+ // vec<3, valType> s = glm::sin(eulerAngle * valType(0.5));
+ //
+ // this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+ // this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+ // this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+ // this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+ //}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER qua<T, Q>::qua(vec<3, T, Q> const& u, vec<3, T, Q> const& v)
+ {
+ T norm_u_norm_v = sqrt(dot(u, u) * dot(v, v));
+ T real_part = norm_u_norm_v + dot(u, v);
+ vec<3, T, Q> t;
+
+ if(real_part < static_cast<T>(1.e-6f) * norm_u_norm_v)
+ {
+ // If u and v are exactly opposite, rotate 180 degrees
+ // around an arbitrary orthogonal axis. Axis normalisation
+ // can happen later, when we normalise the quaternion.
+ real_part = static_cast<T>(0);
+ t = abs(u.x) > abs(u.z) ? vec<3, T, Q>(-u.y, u.x, static_cast<T>(0)) : vec<3, T, Q>(static_cast<T>(0), -u.z, u.y);
+ }
+ else
+ {
+ // Otherwise, build quaternion the standard way.
+ t = cross(u, v);
+ }
+
+ *this = normalize(qua<T, Q>(real_part, t.x, t.y, t.z));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(vec<3, T, Q> const& eulerAngle)
+ {
+ vec<3, T, Q> c = glm::cos(eulerAngle * T(0.5));
+ vec<3, T, Q> s = glm::sin(eulerAngle * T(0.5));
+
+ this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+ this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+ this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+ this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<3, 3, T, Q> const& m)
+ {
+ *this = quat_cast(m);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER qua<T, Q>::qua(mat<4, 4, T, Q> const& m)
+ {
+ *this = quat_cast(m);
+ }
+
+# if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<3, 3, T, Q>() const
+ {
+ return mat3_cast(*this);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER qua<T, Q>::operator mat<4, 4, T, Q>() const
+ {
+ return mat4_cast(*this);
+ }
+# endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
+
+ // -- Unary arithmetic operators --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<T, Q> const& q)
+ {
+ this->w = q.w;
+ this->x = q.x;
+ this->y = q.y;
+ this->z = q.z;
+ return *this;
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<U, Q> const& q)
+ {
+ this->w = static_cast<T>(q.w);
+ this->x = static_cast<T>(q.x);
+ this->y = static_cast<T>(q.y);
+ this->z = static_cast<T>(q.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator+=(qua<U, Q> const& q)
+ {
+ return (*this = detail::compute_quat_add<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator-=(qua<U, Q> const& q)
+ {
+ return (*this = detail::compute_quat_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, qua<T, Q>(q)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator*=(qua<U, Q> const& r)
+ {
+ qua<T, Q> const p(*this);
+ qua<T, Q> const q(r);
+
+ this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z;
+ this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y;
+ this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z;
+ this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator*=(U s)
+ {
+ return (*this = detail::compute_quat_mul_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator/=(U s)
+ {
+ return (*this = detail::compute_quat_div_scalar<T, Q, detail::is_aligned<Q>::value>::call(*this, static_cast<U>(s)));
+ }
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q)
+ {
+ return q;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q)
+ {
+ return qua<T, Q>(-q.w, -q.x, -q.y, -q.z);
+ }
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator+(qua<T, Q> const& q, qua<T, Q> const& p)
+ {
+ return qua<T, Q>(q) += p;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator-(qua<T, Q> const& q, qua<T, Q> const& p)
+ {
+ return qua<T, Q>(q) -= p;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, qua<T, Q> const& p)
+ {
+ return qua<T, Q>(q) *= p;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(qua<T, Q> const& q, vec<3, T, Q> const& v)
+ {
+ vec<3, T, Q> const QuatVector(q.x, q.y, q.z);
+ vec<3, T, Q> const uv(glm::cross(QuatVector, v));
+ vec<3, T, Q> const uuv(glm::cross(QuatVector, uv));
+
+ return v + ((uv * q.w) + uuv) * static_cast<T>(2);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, qua<T, Q> const& q)
+ {
+ return glm::inverse(q) * v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(qua<T, Q> const& q, vec<4, T, Q> const& v)
+ {
+ return detail::compute_quat_mul_vec4<T, Q, detail::is_aligned<Q>::value>::call(q, v);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, qua<T, Q> const& q)
+ {
+ return glm::inverse(q) * v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(qua<T, Q> const& q, T const& s)
+ {
+ return qua<T, Q>(
+ q.w * s, q.x * s, q.y * s, q.z * s);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator*(T const& s, qua<T, Q> const& q)
+ {
+ return q * s;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> operator/(qua<T, Q> const& q, T const& s)
+ {
+ return qua<T, Q>(
+ q.w / s, q.x / s, q.y / s, q.z / s);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(qua<T, Q> const& q1, qua<T, Q> const& q2)
+ {
+ return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(qua<T, Q> const& q1, qua<T, Q> const& q2)
+ {
+ return q1.x != q2.x || q1.y != q2.y || q1.z != q2.z || q1.w != q2.w;
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "type_quat_simd.inl"
+#endif
+
diff --git a/src/include/glm/detail/type_quat_simd.inl b/src/include/glm/detail/type_quat_simd.inl new file mode 100644 index 0000000..2d4e68c --- /dev/null +++ b/src/include/glm/detail/type_quat_simd.inl @@ -0,0 +1,188 @@ +/// @ref core
+
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+/*
+ template<qualifier Q>
+ struct compute_quat_mul<float, Q, true>
+ {
+ static qua<float, Q> call(qua<float, Q> const& q1, qua<float, Q> const& q2)
+ {
+ // SSE2 STATS: 11 shuffle, 8 mul, 8 add
+ // SSE4 STATS: 3 shuffle, 4 mul, 4 dpps
+
+ __m128 const mul0 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(0, 1, 2, 3)));
+ __m128 const mul1 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(1, 0, 3, 2)));
+ __m128 const mul2 = _mm_mul_ps(q1.Data, _mm_shuffle_ps(q2.Data, q2.Data, _MM_SHUFFLE(2, 3, 0, 1)));
+ __m128 const mul3 = _mm_mul_ps(q1.Data, q2.Data);
+
+# if GLM_ARCH & GLM_ARCH_SSE41_BIT
+ __m128 const add0 = _mm_dp_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f), 0xff);
+ __m128 const add1 = _mm_dp_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f), 0xff);
+ __m128 const add2 = _mm_dp_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f), 0xff);
+ __m128 const add3 = _mm_dp_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f), 0xff);
+# else
+ __m128 const mul4 = _mm_mul_ps(mul0, _mm_set_ps(1.0f, -1.0f, 1.0f, 1.0f));
+ __m128 const add0 = _mm_add_ps(mul0, _mm_movehl_ps(mul4, mul4));
+ __m128 const add4 = _mm_add_ss(add0, _mm_shuffle_ps(add0, add0, 1));
+
+ __m128 const mul5 = _mm_mul_ps(mul1, _mm_set_ps(1.0f, 1.0f, 1.0f, -1.0f));
+ __m128 const add1 = _mm_add_ps(mul1, _mm_movehl_ps(mul5, mul5));
+ __m128 const add5 = _mm_add_ss(add1, _mm_shuffle_ps(add1, add1, 1));
+
+ __m128 const mul6 = _mm_mul_ps(mul2, _mm_set_ps(1.0f, 1.0f, -1.0f, 1.0f));
+ __m128 const add2 = _mm_add_ps(mul6, _mm_movehl_ps(mul6, mul6));
+ __m128 const add6 = _mm_add_ss(add2, _mm_shuffle_ps(add2, add2, 1));
+
+ __m128 const mul7 = _mm_mul_ps(mul3, _mm_set_ps(1.0f, -1.0f, -1.0f, -1.0f));
+ __m128 const add3 = _mm_add_ps(mul3, _mm_movehl_ps(mul7, mul7));
+ __m128 const add7 = _mm_add_ss(add3, _mm_shuffle_ps(add3, add3, 1));
+ #endif
+
+ // This SIMD code is a politically correct way of doing this, but in every test I've tried it has been slower than
+ // the final code below. I'll keep this here for reference - maybe somebody else can do something better...
+ //
+ //__m128 xxyy = _mm_shuffle_ps(add4, add5, _MM_SHUFFLE(0, 0, 0, 0));
+ //__m128 zzww = _mm_shuffle_ps(add6, add7, _MM_SHUFFLE(0, 0, 0, 0));
+ //
+ //return _mm_shuffle_ps(xxyy, zzww, _MM_SHUFFLE(2, 0, 2, 0));
+
+ qua<float, Q> Result;
+ _mm_store_ss(&Result.x, add4);
+ _mm_store_ss(&Result.y, add5);
+ _mm_store_ss(&Result.z, add6);
+ _mm_store_ss(&Result.w, add7);
+ return Result;
+ }
+ };
+*/
+
+ template<qualifier Q>
+ struct compute_quat_add<float, Q, true>
+ {
+ static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+ {
+ qua<float, Q> Result;
+ Result.data = _mm_add_ps(q.data, p.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_quat_add<double, Q, true>
+ {
+ static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+ {
+ qua<double, Q> Result;
+ Result.data = _mm256_add_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_quat_sub<float, Q, true>
+ {
+ static qua<float, Q> call(qua<float, Q> const& q, qua<float, Q> const& p)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_sub_ps(q.data, p.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_quat_sub<double, Q, true>
+ {
+ static qua<double, Q> call(qua<double, Q> const& a, qua<double, Q> const& b)
+ {
+ qua<double, Q> Result;
+ Result.data = _mm256_sub_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_quat_mul_scalar<float, Q, true>
+ {
+ static qua<float, Q> call(qua<float, Q> const& q, float s)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_mul_ps(q.data, _mm_set_ps1(s));
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_quat_mul_scalar<double, Q, true>
+ {
+ static qua<double, Q> call(qua<double, Q> const& q, double s)
+ {
+ qua<double, Q> Result;
+ Result.data = _mm256_mul_pd(q.data, _mm_set_ps1(s));
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_quat_div_scalar<float, Q, true>
+ {
+ static qua<float, Q> call(qua<float, Q> const& q, float s)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_div_ps(q.data, _mm_set_ps1(s));
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_quat_div_scalar<double, Q, true>
+ {
+ static qua<double, Q> call(qua<double, Q> const& q, double s)
+ {
+ qua<double, Q> Result;
+ Result.data = _mm256_div_pd(q.data, _mm_set_ps1(s));
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_quat_mul_vec4<float, Q, true>
+ {
+ static vec<4, float, Q> call(qua<float, Q> const& q, vec<4, float, Q> const& v)
+ {
+ __m128 const q_wwww = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 3, 3, 3));
+ __m128 const q_swp0 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 0, 2, 1));
+ __m128 const q_swp1 = _mm_shuffle_ps(q.data, q.data, _MM_SHUFFLE(3, 1, 0, 2));
+ __m128 const v_swp0 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 0, 2, 1));
+ __m128 const v_swp1 = _mm_shuffle_ps(v.data, v.data, _MM_SHUFFLE(3, 1, 0, 2));
+
+ __m128 uv = _mm_sub_ps(_mm_mul_ps(q_swp0, v_swp1), _mm_mul_ps(q_swp1, v_swp0));
+ __m128 uv_swp0 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 0, 2, 1));
+ __m128 uv_swp1 = _mm_shuffle_ps(uv, uv, _MM_SHUFFLE(3, 1, 0, 2));
+ __m128 uuv = _mm_sub_ps(_mm_mul_ps(q_swp0, uv_swp1), _mm_mul_ps(q_swp1, uv_swp0));
+
+ __m128 const two = _mm_set1_ps(2.0f);
+ uv = _mm_mul_ps(uv, _mm_mul_ps(q_wwww, two));
+ uuv = _mm_mul_ps(uuv, two);
+
+ vec<4, float, Q> Result;
+ Result.data = _mm_add_ps(v.Data, _mm_add_ps(uv, uuv));
+ return Result;
+ }
+ };
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
diff --git a/src/include/glm/detail/type_vec1.hpp b/src/include/glm/detail/type_vec1.hpp new file mode 100644 index 0000000..6a7df10 --- /dev/null +++ b/src/include/glm/detail/type_vec1.hpp @@ -0,0 +1,308 @@ +/// @ref core
+/// @file glm/detail/type_vec1.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+# include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+# include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct vec<1, T, Q>
+ {
+ // -- Implementation detail --
+
+ typedef T value_type;
+ typedef vec<1, T, Q> type;
+ typedef vec<1, bool, Q> bool_type;
+
+ // -- Data --
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+# pragma clang diagnostic ignored "-Wnested-anon-types"
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+# endif
+# endif
+
+# if GLM_CONFIG_XYZW_ONLY
+ T x;
+# elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+ union
+ {
+ T x;
+ T r;
+ T s;
+
+ typename detail::storage<1, T, detail::is_aligned<Q>::value>::type data;
+/*
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ _GLM_SWIZZLE1_2_MEMBERS(T, Q, x)
+ _GLM_SWIZZLE1_2_MEMBERS(T, Q, r)
+ _GLM_SWIZZLE1_2_MEMBERS(T, Q, s)
+ _GLM_SWIZZLE1_3_MEMBERS(T, Q, x)
+ _GLM_SWIZZLE1_3_MEMBERS(T, Q, r)
+ _GLM_SWIZZLE1_3_MEMBERS(T, Q, s)
+ _GLM_SWIZZLE1_4_MEMBERS(T, Q, x)
+ _GLM_SWIZZLE1_4_MEMBERS(T, Q, r)
+ _GLM_SWIZZLE1_4_MEMBERS(T, Q, s)
+# endif
+*/
+ };
+# else
+ union {T x, r, s;};
+/*
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q)
+# endif
+*/
+# endif
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+# endif
+
+ // -- Component accesses --
+
+ /// Return the count of components of the vector
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;}
+
+ GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+ // -- Implicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, P> const& v);
+
+ // -- Explicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+
+ // -- Conversion vector constructors --
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, P> const& v);
+
+ // -- Swizzle constructors --
+/*
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ template<int E0>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<1, T, Q, E0, -1,-2,-3> const& that)
+ {
+ *this = that();
+ }
+# endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+*/
+ // -- Unary arithmetic operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator+=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator-=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator*=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator/=(vec<1, U, Q> const& v);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator++();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator--();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator++(int);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator--(int);
+
+ // -- Unary bit operators --
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator%=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator&=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator|=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator^=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator<<=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator>>=(vec<1, U, Q> const& v);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec1.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_vec1.inl b/src/include/glm/detail/type_vec1.inl new file mode 100644 index 0000000..b7e36cf --- /dev/null +++ b/src/include/glm/detail/type_vec1.inl @@ -0,0 +1,551 @@ +/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+ // -- Implicit basic constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec()
+# if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+ : x(0)
+# endif
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, Q> const& v)
+ : x(v.x)
+ {}
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, P> const& v)
+ : x(v.x)
+ {}
+
+ // -- Explicit basic constructors --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(T scalar)
+ : x(scalar)
+ {}
+
+ // -- Conversion vector constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<2, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<3, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<4, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ {}
+
+ // -- Component accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type)
+ {
+ return x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<1, T, Q>::operator[](typename vec<1, T, Q>::length_type) const
+ {
+ return x;
+ }
+
+ // -- Unary arithmetic operators --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v)
+ {
+ this->x = v.x;
+ return *this;
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v)
+ {
+ this->x = static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(U scalar)
+ {
+ this->x += static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator+=(vec<1, U, Q> const& v)
+ {
+ this->x += static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(U scalar)
+ {
+ this->x -= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator-=(vec<1, U, Q> const& v)
+ {
+ this->x -= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(U scalar)
+ {
+ this->x *= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator*=(vec<1, U, Q> const& v)
+ {
+ this->x *= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(U scalar)
+ {
+ this->x /= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator/=(vec<1, U, Q> const& v)
+ {
+ this->x /= static_cast<T>(v.x);
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator++()
+ {
+ ++this->x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator--()
+ {
+ --this->x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator++(int)
+ {
+ vec<1, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> vec<1, T, Q>::operator--(int)
+ {
+ vec<1, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(U scalar)
+ {
+ this->x %= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator%=(vec<1, U, Q> const& v)
+ {
+ this->x %= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(U scalar)
+ {
+ this->x &= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator&=(vec<1, U, Q> const& v)
+ {
+ this->x &= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(U scalar)
+ {
+ this->x |= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator|=(vec<1, U, Q> const& v)
+ {
+ this->x |= U(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(U scalar)
+ {
+ this->x ^= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator^=(vec<1, U, Q> const& v)
+ {
+ this->x ^= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(U scalar)
+ {
+ this->x <<= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator<<=(vec<1, U, Q> const& v)
+ {
+ this->x <<= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(U scalar)
+ {
+ this->x >>= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator>>=(vec<1, U, Q> const& v)
+ {
+ this->x >>= static_cast<T>(v.x);
+ return *this;
+ }
+
+ // -- Unary constant operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v)
+ {
+ return v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ -v.x);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar + v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator+(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x + v2.x);
+ }
+
+ //operator-
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar - v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator-(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x - v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar * v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator*(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x * v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar / v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator/(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x / v2.x);
+ }
+
+ // -- Binary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x % scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar % v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator%(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x % v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x & scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar & v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator&(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x & v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x | scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar | v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator|(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x | v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ v.x ^ scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ scalar ^ v.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator^(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ v1.x ^ v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(v.x << scalar));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(scalar << v.x));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator<<(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(v1.x << v2.x));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v, T scalar)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(v.x >> scalar));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(T scalar, vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(scalar >> v.x));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator>>(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<1, T, Q>(
+ static_cast<T>(v1.x >> v2.x));
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> operator~(vec<1, T, Q> const& v)
+ {
+ return vec<1, T, Q>(
+ ~v.x);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<1, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return !(v1 == v2);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator&&(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+ {
+ return vec<1, bool, Q>(v1.x && v2.x);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, bool, Q> operator||(vec<1, bool, Q> const& v1, vec<1, bool, Q> const& v2)
+ {
+ return vec<1, bool, Q>(v1.x || v2.x);
+ }
+}//namespace glm
diff --git a/src/include/glm/detail/type_vec2.hpp b/src/include/glm/detail/type_vec2.hpp new file mode 100644 index 0000000..f13555f --- /dev/null +++ b/src/include/glm/detail/type_vec2.hpp @@ -0,0 +1,399 @@ +/// @ref core
+/// @file glm/detail/type_vec2.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+# include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+# include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct vec<2, T, Q>
+ {
+ // -- Implementation detail --
+
+ typedef T value_type;
+ typedef vec<2, T, Q> type;
+ typedef vec<2, bool, Q> bool_type;
+
+ // -- Data --
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+# pragma clang diagnostic ignored "-Wnested-anon-types"
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+# endif
+# endif
+
+# if GLM_CONFIG_XYZW_ONLY
+ T x, y;
+# elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+ union
+ {
+ struct{ T x, y; };
+ struct{ T r, g; };
+ struct{ T s, t; };
+
+ typename detail::storage<2, T, detail::is_aligned<Q>::value>::type data;
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y)
+ GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g)
+ GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t)
+ GLM_SWIZZLE2_3_MEMBERS(T, Q, x, y)
+ GLM_SWIZZLE2_3_MEMBERS(T, Q, r, g)
+ GLM_SWIZZLE2_3_MEMBERS(T, Q, s, t)
+ GLM_SWIZZLE2_4_MEMBERS(T, Q, x, y)
+ GLM_SWIZZLE2_4_MEMBERS(T, Q, r, g)
+ GLM_SWIZZLE2_4_MEMBERS(T, Q, s, t)
+# endif
+ };
+# else
+ union {T x, r, s;};
+ union {T y, g, t;};
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q)
+# endif//GLM_CONFIG_SWIZZLE
+# endif
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+# endif
+
+ // -- Component accesses --
+
+ /// Return the count of components of the vector
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+
+ GLM_FUNC_DECL GLM_CONSTEXPR T& operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+ // -- Implicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, P> const& v);
+
+ // -- Explicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y);
+
+ // -- Conversion constructors --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y);
+ template<typename A, typename B>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, B y);
+ template<typename A, typename B>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, vec<1, B, Q> const& y);
+ template<typename A, typename B>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const& x, vec<1, B, Q> const& y);
+
+ // -- Conversion vector constructors --
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, P> const& v);
+
+ // -- Swizzle constructors --
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that)
+ {
+ *this = that();
+ }
+# endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+ // -- Unary arithmetic operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator+=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator-=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator*=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator/=(vec<2, U, Q> const& v);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator++();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator--();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator++(int);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator--(int);
+
+ // -- Unary bit operators --
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator%=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator&=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator|=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator^=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator<<=(vec<2, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator>>=(vec<2, U, Q> const& v);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec2.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_vec2.inl b/src/include/glm/detail/type_vec2.inl new file mode 100644 index 0000000..ce61184 --- /dev/null +++ b/src/include/glm/detail/type_vec2.inl @@ -0,0 +1,913 @@ +/// @ref core
+
+#include "./compute_vector_relational.hpp"
+
+namespace glm
+{
+ // -- Implicit basic constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec()
+# if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+ : x(0), y(0)
+# endif
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, Q> const& v)
+ : x(v.x), y(v.y)
+ {}
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, P> const& v)
+ : x(v.x), y(v.y)
+ {}
+
+ // -- Explicit basic constructors --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T scalar)
+ : x(scalar), y(scalar)
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(T _x, T _y)
+ : x(_x), y(_y)
+ {}
+
+ // -- Conversion scalar constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, B _y)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, B _y)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(A _x, vec<1, B, Q> const& _y)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ {}
+
+ // -- Conversion vector constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<3, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<4, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ {}
+
+ // -- Component accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i)
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ }
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<2, T, Q>::operator[](typename vec<2, T, Q>::length_type i) const
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ }
+ }
+
+ // -- Unary arithmetic operators --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v)
+ {
+ this->x = v.x;
+ this->y = v.y;
+ return *this;
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v)
+ {
+ this->x = static_cast<T>(v.x);
+ this->y = static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(U scalar)
+ {
+ this->x += static_cast<T>(scalar);
+ this->y += static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<1, U, Q> const& v)
+ {
+ this->x += static_cast<T>(v.x);
+ this->y += static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator+=(vec<2, U, Q> const& v)
+ {
+ this->x += static_cast<T>(v.x);
+ this->y += static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(U scalar)
+ {
+ this->x -= static_cast<T>(scalar);
+ this->y -= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<1, U, Q> const& v)
+ {
+ this->x -= static_cast<T>(v.x);
+ this->y -= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator-=(vec<2, U, Q> const& v)
+ {
+ this->x -= static_cast<T>(v.x);
+ this->y -= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(U scalar)
+ {
+ this->x *= static_cast<T>(scalar);
+ this->y *= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<1, U, Q> const& v)
+ {
+ this->x *= static_cast<T>(v.x);
+ this->y *= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator*=(vec<2, U, Q> const& v)
+ {
+ this->x *= static_cast<T>(v.x);
+ this->y *= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(U scalar)
+ {
+ this->x /= static_cast<T>(scalar);
+ this->y /= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<1, U, Q> const& v)
+ {
+ this->x /= static_cast<T>(v.x);
+ this->y /= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator/=(vec<2, U, Q> const& v)
+ {
+ this->x /= static_cast<T>(v.x);
+ this->y /= static_cast<T>(v.y);
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator++()
+ {
+ ++this->x;
+ ++this->y;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator--()
+ {
+ --this->x;
+ --this->y;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator++(int)
+ {
+ vec<2, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> vec<2, T, Q>::operator--(int)
+ {
+ vec<2, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(U scalar)
+ {
+ this->x %= static_cast<T>(scalar);
+ this->y %= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<1, U, Q> const& v)
+ {
+ this->x %= static_cast<T>(v.x);
+ this->y %= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator%=(vec<2, U, Q> const& v)
+ {
+ this->x %= static_cast<T>(v.x);
+ this->y %= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(U scalar)
+ {
+ this->x &= static_cast<T>(scalar);
+ this->y &= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<1, U, Q> const& v)
+ {
+ this->x &= static_cast<T>(v.x);
+ this->y &= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator&=(vec<2, U, Q> const& v)
+ {
+ this->x &= static_cast<T>(v.x);
+ this->y &= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(U scalar)
+ {
+ this->x |= static_cast<T>(scalar);
+ this->y |= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<1, U, Q> const& v)
+ {
+ this->x |= static_cast<T>(v.x);
+ this->y |= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator|=(vec<2, U, Q> const& v)
+ {
+ this->x |= static_cast<T>(v.x);
+ this->y |= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(U scalar)
+ {
+ this->x ^= static_cast<T>(scalar);
+ this->y ^= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<1, U, Q> const& v)
+ {
+ this->x ^= static_cast<T>(v.x);
+ this->y ^= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator^=(vec<2, U, Q> const& v)
+ {
+ this->x ^= static_cast<T>(v.x);
+ this->y ^= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(U scalar)
+ {
+ this->x <<= static_cast<T>(scalar);
+ this->y <<= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<1, U, Q> const& v)
+ {
+ this->x <<= static_cast<T>(v.x);
+ this->y <<= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator<<=(vec<2, U, Q> const& v)
+ {
+ this->x <<= static_cast<T>(v.x);
+ this->y <<= static_cast<T>(v.y);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(U scalar)
+ {
+ this->x >>= static_cast<T>(scalar);
+ this->y >>= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<1, U, Q> const& v)
+ {
+ this->x >>= static_cast<T>(v.x);
+ this->y >>= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator>>=(vec<2, U, Q> const& v)
+ {
+ this->x >>= static_cast<T>(v.x);
+ this->y >>= static_cast<T>(v.y);
+ return *this;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v)
+ {
+ return v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ -v.x,
+ -v.y);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x + scalar,
+ v.y + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x + v2.x,
+ v1.y + v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar + v.x,
+ scalar + v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x + v2.x,
+ v1.x + v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator+(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x + v2.x,
+ v1.y + v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x - scalar,
+ v.y - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x - v2.x,
+ v1.y - v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar - v.x,
+ scalar - v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x - v2.x,
+ v1.x - v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator-(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x - v2.x,
+ v1.y - v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x * scalar,
+ v.y * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x * v2.x,
+ v1.y * v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar * v.x,
+ scalar * v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x * v2.x,
+ v1.x * v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator*(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x * v2.x,
+ v1.y * v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x / scalar,
+ v.y / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x / v2.x,
+ v1.y / v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar / v.x,
+ scalar / v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x / v2.x,
+ v1.x / v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator/(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x / v2.x,
+ v1.y / v2.y);
+ }
+
+ // -- Binary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x % scalar,
+ v.y % scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x % v2.x,
+ v1.y % v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar % v.x,
+ scalar % v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x % v2.x,
+ v1.x % v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator%(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x % v2.x,
+ v1.y % v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x & scalar,
+ v.y & scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x & v2.x,
+ v1.y & v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar & v.x,
+ scalar & v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x & v2.x,
+ v1.x & v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator&(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x & v2.x,
+ v1.y & v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x | scalar,
+ v.y | scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x | v2.x,
+ v1.y | v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar | v.x,
+ scalar | v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x | v2.x,
+ v1.x | v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator|(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x | v2.x,
+ v1.y | v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x ^ scalar,
+ v.y ^ scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x ^ v2.x,
+ v1.y ^ v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar ^ v.x,
+ scalar ^ v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x ^ v2.x,
+ v1.x ^ v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator^(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x ^ v2.x,
+ v1.y ^ v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x << scalar,
+ v.y << scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x << v2.x,
+ v1.y << v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar << v.x,
+ scalar << v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x << v2.x,
+ v1.x << v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator<<(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x << v2.x,
+ v1.y << v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v, T scalar)
+ {
+ return vec<2, T, Q>(
+ v.x >> scalar,
+ v.y >> scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x >> v2.x,
+ v1.y >> v2.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(T scalar, vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ scalar >> v.x,
+ scalar >> v.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<1, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x >> v2.x,
+ v1.x >> v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator>>(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return vec<2, T, Q>(
+ v1.x >> v2.x,
+ v1.y >> v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> operator~(vec<2, T, Q> const& v)
+ {
+ return vec<2, T, Q>(
+ ~v.x,
+ ~v.y);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<2, T, Q> const& v1, vec<2, T, Q> const& v2)
+ {
+ return !(v1 == v2);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator&&(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+ {
+ return vec<2, bool, Q>(v1.x && v2.x, v1.y && v2.y);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, bool, Q> operator||(vec<2, bool, Q> const& v1, vec<2, bool, Q> const& v2)
+ {
+ return vec<2, bool, Q>(v1.x || v2.x, v1.y || v2.y);
+ }
+}//namespace glm
diff --git a/src/include/glm/detail/type_vec3.hpp b/src/include/glm/detail/type_vec3.hpp new file mode 100644 index 0000000..2ad1364 --- /dev/null +++ b/src/include/glm/detail/type_vec3.hpp @@ -0,0 +1,432 @@ +/// @ref core
+/// @file glm/detail/type_vec3.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+# include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+# include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct vec<3, T, Q>
+ {
+ // -- Implementation detail --
+
+ typedef T value_type;
+ typedef vec<3, T, Q> type;
+ typedef vec<3, bool, Q> bool_type;
+
+ // -- Data --
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+# pragma clang diagnostic ignored "-Wnested-anon-types"
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+# pragma warning(disable: 4324) // structure was padded due to alignment specifier
+# endif
+# endif
+# endif
+
+# if GLM_CONFIG_XYZW_ONLY
+ T x, y, z;
+# elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+ union
+ {
+ struct{ T x, y, z; };
+ struct{ T r, g, b; };
+ struct{ T s, t, p; };
+
+ typename detail::storage<3, T, detail::is_aligned<Q>::value>::type data;
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z)
+ GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b)
+ GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p)
+ GLM_SWIZZLE3_3_MEMBERS(T, Q, x, y, z)
+ GLM_SWIZZLE3_3_MEMBERS(T, Q, r, g, b)
+ GLM_SWIZZLE3_3_MEMBERS(T, Q, s, t, p)
+ GLM_SWIZZLE3_4_MEMBERS(T, Q, x, y, z)
+ GLM_SWIZZLE3_4_MEMBERS(T, Q, r, g, b)
+ GLM_SWIZZLE3_4_MEMBERS(T, Q, s, t, p)
+# endif
+ };
+# else
+ union { T x, r, s; };
+ union { T y, g, t; };
+ union { T z, b, p; };
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q)
+# endif//GLM_CONFIG_SWIZZLE
+# endif//GLM_LANG
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+# endif
+
+ // -- Component accesses --
+
+ /// Return the count of components of the vector
+ typedef length_t length_type;
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;}
+
+ GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+ // -- Implicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, P> const& v);
+
+ // -- Explicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c);
+
+ // -- Conversion scalar constructors --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X x, Y y, Z z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z);
+
+ // -- Conversion vector constructors --
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, P> const& v);
+
+ // -- Swizzle constructors --
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ template<int E0, int E1, int E2>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that)
+ {
+ *this = that();
+ }
+
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& scalar)
+ {
+ *this = vec(v(), scalar);
+ }
+
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& scalar, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+ {
+ *this = vec(scalar, v());
+ }
+# endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+ // -- Unary arithmetic operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT;
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator+=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator-=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator*=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator/=(vec<3, U, Q> const& v);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator++();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator--();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator++(int);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator--(int);
+
+ // -- Unary bit operators --
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator%=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator&=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator|=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator^=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator<<=(vec<3, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> & operator>>=(vec<3, U, Q> const& v);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec3.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_vec3.inl b/src/include/glm/detail/type_vec3.inl new file mode 100644 index 0000000..f4972e0 --- /dev/null +++ b/src/include/glm/detail/type_vec3.inl @@ -0,0 +1,1068 @@ +/// @ref core
+
+#include "compute_vector_relational.hpp"
+
+namespace glm
+{
+ // -- Implicit basic constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec()
+# if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+ : x(0), y(0), z(0)
+# endif
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, Q> const& v)
+ : x(v.x), y(v.y), z(v.z)
+ {}
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, P> const& v)
+ : x(v.x), y(v.y), z(v.z)
+ {}
+
+ // -- Explicit basic constructors --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T scalar)
+ : x(scalar), y(scalar), z(scalar)
+ {}
+
+ template <typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(T _x, T _y, T _z)
+ : x(_x), y(_y), z(_z)
+ {}
+
+ // -- Conversion scalar constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.x))
+ , z(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, Z _z)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ {}
+
+ // -- Conversion vector constructors --
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, B _z)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(A _x, vec<2, B, P> const& _yz)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ , z(static_cast<T>(v.z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<4, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ , z(static_cast<T>(v.z))
+ {}
+
+ // -- Component accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T & vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i)
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ case 2:
+ return z;
+ }
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<3, T, Q>::operator[](typename vec<3, T, Q>::length_type i) const
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ case 2:
+ return z;
+ }
+ }
+
+ // -- Unary arithmetic operators --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v)
+ {
+ this->x = v.x;
+ this->y = v.y;
+ this->z = v.z;
+ return *this;
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v)
+ {
+ this->x = static_cast<T>(v.x);
+ this->y = static_cast<T>(v.y);
+ this->z = static_cast<T>(v.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(U scalar)
+ {
+ this->x += static_cast<T>(scalar);
+ this->y += static_cast<T>(scalar);
+ this->z += static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<1, U, Q> const& v)
+ {
+ this->x += static_cast<T>(v.x);
+ this->y += static_cast<T>(v.x);
+ this->z += static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator+=(vec<3, U, Q> const& v)
+ {
+ this->x += static_cast<T>(v.x);
+ this->y += static_cast<T>(v.y);
+ this->z += static_cast<T>(v.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(U scalar)
+ {
+ this->x -= static_cast<T>(scalar);
+ this->y -= static_cast<T>(scalar);
+ this->z -= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<1, U, Q> const& v)
+ {
+ this->x -= static_cast<T>(v.x);
+ this->y -= static_cast<T>(v.x);
+ this->z -= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator-=(vec<3, U, Q> const& v)
+ {
+ this->x -= static_cast<T>(v.x);
+ this->y -= static_cast<T>(v.y);
+ this->z -= static_cast<T>(v.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(U scalar)
+ {
+ this->x *= static_cast<T>(scalar);
+ this->y *= static_cast<T>(scalar);
+ this->z *= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<1, U, Q> const& v)
+ {
+ this->x *= static_cast<T>(v.x);
+ this->y *= static_cast<T>(v.x);
+ this->z *= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator*=(vec<3, U, Q> const& v)
+ {
+ this->x *= static_cast<T>(v.x);
+ this->y *= static_cast<T>(v.y);
+ this->z *= static_cast<T>(v.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(U v)
+ {
+ this->x /= static_cast<T>(v);
+ this->y /= static_cast<T>(v);
+ this->z /= static_cast<T>(v);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<1, U, Q> const& v)
+ {
+ this->x /= static_cast<T>(v.x);
+ this->y /= static_cast<T>(v.x);
+ this->z /= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator/=(vec<3, U, Q> const& v)
+ {
+ this->x /= static_cast<T>(v.x);
+ this->y /= static_cast<T>(v.y);
+ this->z /= static_cast<T>(v.z);
+ return *this;
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator++()
+ {
+ ++this->x;
+ ++this->y;
+ ++this->z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator--()
+ {
+ --this->x;
+ --this->y;
+ --this->z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator++(int)
+ {
+ vec<3, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> vec<3, T, Q>::operator--(int)
+ {
+ vec<3, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(U scalar)
+ {
+ this->x %= scalar;
+ this->y %= scalar;
+ this->z %= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<1, U, Q> const& v)
+ {
+ this->x %= v.x;
+ this->y %= v.x;
+ this->z %= v.x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator%=(vec<3, U, Q> const& v)
+ {
+ this->x %= v.x;
+ this->y %= v.y;
+ this->z %= v.z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(U scalar)
+ {
+ this->x &= scalar;
+ this->y &= scalar;
+ this->z &= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<1, U, Q> const& v)
+ {
+ this->x &= v.x;
+ this->y &= v.x;
+ this->z &= v.x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator&=(vec<3, U, Q> const& v)
+ {
+ this->x &= v.x;
+ this->y &= v.y;
+ this->z &= v.z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(U scalar)
+ {
+ this->x |= scalar;
+ this->y |= scalar;
+ this->z |= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<1, U, Q> const& v)
+ {
+ this->x |= v.x;
+ this->y |= v.x;
+ this->z |= v.x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator|=(vec<3, U, Q> const& v)
+ {
+ this->x |= v.x;
+ this->y |= v.y;
+ this->z |= v.z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(U scalar)
+ {
+ this->x ^= scalar;
+ this->y ^= scalar;
+ this->z ^= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<1, U, Q> const& v)
+ {
+ this->x ^= v.x;
+ this->y ^= v.x;
+ this->z ^= v.x;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator^=(vec<3, U, Q> const& v)
+ {
+ this->x ^= v.x;
+ this->y ^= v.y;
+ this->z ^= v.z;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(U scalar)
+ {
+ this->x <<= scalar;
+ this->y <<= scalar;
+ this->z <<= scalar;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<1, U, Q> const& v)
+ {
+ this->x <<= static_cast<T>(v.x);
+ this->y <<= static_cast<T>(v.x);
+ this->z <<= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator<<=(vec<3, U, Q> const& v)
+ {
+ this->x <<= static_cast<T>(v.x);
+ this->y <<= static_cast<T>(v.y);
+ this->z <<= static_cast<T>(v.z);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(U scalar)
+ {
+ this->x >>= static_cast<T>(scalar);
+ this->y >>= static_cast<T>(scalar);
+ this->z >>= static_cast<T>(scalar);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<1, U, Q> const& v)
+ {
+ this->x >>= static_cast<T>(v.x);
+ this->y >>= static_cast<T>(v.x);
+ this->z >>= static_cast<T>(v.x);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> & vec<3, T, Q>::operator>>=(vec<3, U, Q> const& v)
+ {
+ this->x >>= static_cast<T>(v.x);
+ this->y >>= static_cast<T>(v.y);
+ this->z >>= static_cast<T>(v.z);
+ return *this;
+ }
+
+ // -- Unary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v)
+ {
+ return v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ -v.x,
+ -v.y,
+ -v.z);
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x + scalar,
+ v.y + scalar,
+ v.z + scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x + scalar.x,
+ v.y + scalar.x,
+ v.z + scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar + v.x,
+ scalar + v.y,
+ scalar + v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x + v.x,
+ scalar.x + v.y,
+ scalar.x + v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator+(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x + v2.x,
+ v1.y + v2.y,
+ v1.z + v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x - scalar,
+ v.y - scalar,
+ v.z - scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x - scalar.x,
+ v.y - scalar.x,
+ v.z - scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar - v.x,
+ scalar - v.y,
+ scalar - v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x - v.x,
+ scalar.x - v.y,
+ scalar.x - v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator-(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x - v2.x,
+ v1.y - v2.y,
+ v1.z - v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x * scalar,
+ v.y * scalar,
+ v.z * scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x * scalar.x,
+ v.y * scalar.x,
+ v.z * scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar * v.x,
+ scalar * v.y,
+ scalar * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x * v.x,
+ scalar.x * v.y,
+ scalar.x * v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator*(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x * v2.x,
+ v1.y * v2.y,
+ v1.z * v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x / scalar,
+ v.y / scalar,
+ v.z / scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x / scalar.x,
+ v.y / scalar.x,
+ v.z / scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar / v.x,
+ scalar / v.y,
+ scalar / v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x / v.x,
+ scalar.x / v.y,
+ scalar.x / v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator/(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x / v2.x,
+ v1.y / v2.y,
+ v1.z / v2.z);
+ }
+
+ // -- Binary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x % scalar,
+ v.y % scalar,
+ v.z % scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x % scalar.x,
+ v.y % scalar.x,
+ v.z % scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar % v.x,
+ scalar % v.y,
+ scalar % v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x % v.x,
+ scalar.x % v.y,
+ scalar.x % v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator%(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x % v2.x,
+ v1.y % v2.y,
+ v1.z % v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x & scalar,
+ v.y & scalar,
+ v.z & scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x & scalar.x,
+ v.y & scalar.x,
+ v.z & scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar & v.x,
+ scalar & v.y,
+ scalar & v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x & v.x,
+ scalar.x & v.y,
+ scalar.x & v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator&(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x & v2.x,
+ v1.y & v2.y,
+ v1.z & v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x | scalar,
+ v.y | scalar,
+ v.z | scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x | scalar.x,
+ v.y | scalar.x,
+ v.z | scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar | v.x,
+ scalar | v.y,
+ scalar | v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x | v.x,
+ scalar.x | v.y,
+ scalar.x | v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator|(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x | v2.x,
+ v1.y | v2.y,
+ v1.z | v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x ^ scalar,
+ v.y ^ scalar,
+ v.z ^ scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x ^ scalar.x,
+ v.y ^ scalar.x,
+ v.z ^ scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar ^ v.x,
+ scalar ^ v.y,
+ scalar ^ v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x ^ v.x,
+ scalar.x ^ v.y,
+ scalar.x ^ v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator^(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x ^ v2.x,
+ v1.y ^ v2.y,
+ v1.z ^ v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x << scalar,
+ v.y << scalar,
+ v.z << scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x << scalar.x,
+ v.y << scalar.x,
+ v.z << scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar << v.x,
+ scalar << v.y,
+ scalar << v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x << v.x,
+ scalar.x << v.y,
+ scalar.x << v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator<<(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x << v2.x,
+ v1.y << v2.y,
+ v1.z << v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, T scalar)
+ {
+ return vec<3, T, Q>(
+ v.x >> scalar,
+ v.y >> scalar,
+ v.z >> scalar);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<3, T, Q>(
+ v.x >> scalar.x,
+ v.y >> scalar.x,
+ v.z >> scalar.x);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(T scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar >> v.x,
+ scalar >> v.y,
+ scalar >> v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ scalar.x >> v.x,
+ scalar.x >> v.y,
+ scalar.x >> v.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator>>(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return vec<3, T, Q>(
+ v1.x >> v2.x,
+ v1.y >> v2.y,
+ v1.z >> v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> operator~(vec<3, T, Q> const& v)
+ {
+ return vec<3, T, Q>(
+ ~v.x,
+ ~v.y,
+ ~v.z);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<3, T, Q> const& v1, vec<3, T, Q> const& v2)
+ {
+ return !(v1 == v2);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator&&(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
+ {
+ return vec<3, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, bool, Q> operator||(vec<3, bool, Q> const& v1, vec<3, bool, Q> const& v2)
+ {
+ return vec<3, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);
+ }
+}//namespace glm
diff --git a/src/include/glm/detail/type_vec4.hpp b/src/include/glm/detail/type_vec4.hpp new file mode 100644 index 0000000..f9d9981 --- /dev/null +++ b/src/include/glm/detail/type_vec4.hpp @@ -0,0 +1,505 @@ +/// @ref core
+/// @file glm/detail/type_vec4.hpp
+
+#pragma once
+
+#include "qualifier.hpp"
+#if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+# include "_swizzle.hpp"
+#elif GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+# include "_swizzle_func.hpp"
+#endif
+#include <cstddef>
+
+namespace glm
+{
+ template<typename T, qualifier Q>
+ struct vec<4, T, Q>
+ {
+ // -- Implementation detail --
+
+ typedef T value_type;
+ typedef vec<4, T, Q> type;
+ typedef vec<4, bool, Q> bool_type;
+
+ // -- Data --
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+# elif GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+# pragma clang diagnostic ignored "-Wnested-anon-types"
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(push)
+# pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+# endif
+# endif
+
+# if GLM_CONFIG_XYZW_ONLY
+ T x, y, z, w;
+# elif GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+ union
+ {
+ struct { T x, y, z, w; };
+ struct { T r, g, b, a; };
+ struct { T s, t, p, q; };
+
+ typename detail::storage<4, T, detail::is_aligned<Q>::value>::type data;
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w)
+ GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a)
+ GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q)
+ GLM_SWIZZLE4_3_MEMBERS(T, Q, x, y, z, w)
+ GLM_SWIZZLE4_3_MEMBERS(T, Q, r, g, b, a)
+ GLM_SWIZZLE4_3_MEMBERS(T, Q, s, t, p, q)
+ GLM_SWIZZLE4_4_MEMBERS(T, Q, x, y, z, w)
+ GLM_SWIZZLE4_4_MEMBERS(T, Q, r, g, b, a)
+ GLM_SWIZZLE4_4_MEMBERS(T, Q, s, t, p, q)
+# endif
+ };
+# else
+ union { T x, r, s; };
+ union { T y, g, t; };
+ union { T z, b, p; };
+ union { T w, a, q; };
+
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+ GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q)
+# endif
+# endif
+
+# if GLM_SILENT_WARNINGS == GLM_ENABLE
+# if GLM_COMPILER & GLM_COMPILER_CLANG
+# pragma clang diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_GCC
+# pragma GCC diagnostic pop
+# elif GLM_COMPILER & GLM_COMPILER_VC
+# pragma warning(pop)
+# endif
+# endif
+
+ // -- Component accesses --
+
+ typedef length_t length_type;
+
+ /// Return the count of components of the vector
+ GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+
+ GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
+ GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
+
+ // -- Implicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT;
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT;
+ template<qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, P> const& v);
+
+ // -- Explicit basic constructors --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T x, T y, T z, T w);
+
+ // -- Conversion scalar constructors --
+
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(vec<1, U, P> const& v);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, Z _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _Y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w);
+
+ // -- Conversion vector constructors --
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, C _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, C _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, B _y, vec<2, C, P> const& _zw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, B _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(A _x, vec<3, B, P> const& _yzw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw);
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw);
+
+ /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+ template<typename U, qualifier P>
+ GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, P> const& v);
+
+ // -- Swizzle constructors --
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ template<int E0, int E1, int E2, int E3>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that)
+ {
+ *this = that();
+ }
+
+ template<int E0, int E1, int F0, int F1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, detail::_swizzle<2, T, Q, F0, F1, -1, -2> const& u)
+ {
+ *this = vec<4, T, Q>(v(), u());
+ }
+
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, T const& y, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v)
+ {
+ *this = vec<4, T, Q>(x, y, v());
+ }
+
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& w)
+ {
+ *this = vec<4, T, Q>(x, v(), w);
+ }
+
+ template<int E0, int E1>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<2, T, Q, E0, E1, -1, -2> const& v, T const& z, T const& w)
+ {
+ *this = vec<4, T, Q>(v(), z, w);
+ }
+
+ template<int E0, int E1, int E2>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v, T const& w)
+ {
+ *this = vec<4, T, Q>(v(), w);
+ }
+
+ template<int E0, int E1, int E2>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec(T const& x, detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& v)
+ {
+ *this = vec<4, T, Q>(x, v());
+ }
+# endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+ // -- Unary arithmetic operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT;
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator+=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator-=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator*=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator/=(vec<4, U, Q> const& v);
+
+ // -- Increment and decrement operators --
+
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator++();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator--();
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator++(int);
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator--(int);
+
+ // -- Unary bit operators --
+
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator%=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator&=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator|=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator^=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator<<=(vec<4, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(U scalar);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<1, U, Q> const& v);
+ template<typename U>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> & operator>>=(vec<4, U, Q> const& v);
+ };
+
+ // -- Unary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v);
+
+ // -- Binary operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v);
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+
+ template<qualifier Q>
+ GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec4.inl"
+#endif//GLM_EXTERNAL_TEMPLATE
diff --git a/src/include/glm/detail/type_vec4.inl b/src/include/glm/detail/type_vec4.inl new file mode 100644 index 0000000..71b8488 --- /dev/null +++ b/src/include/glm/detail/type_vec4.inl @@ -0,0 +1,1140 @@ +/// @ref core
+
+#include "compute_vector_relational.hpp"
+
+namespace glm{
+namespace detail
+{
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_vec4_add
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_vec4_sub
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_vec4_mul
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_vec4_div
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, bool Aligned>
+ struct compute_vec4_mod
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x % b.x, a.y % b.y, a.z % b.z, a.w % b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_and
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x & b.x, a.y & b.y, a.z & b.z, a.w & b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_or
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x | b.x, a.y | b.y, a.z | b.z, a.w | b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_xor
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x ^ b.x, a.y ^ b.y, a.z ^ b.z, a.w ^ b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_shift_left
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x << b.x, a.y << b.y, a.z << b.z, a.w << b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_shift_right
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ return vec<4, T, Q>(a.x >> b.x, a.y >> b.y, a.z >> b.z, a.w >> b.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_equal
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z) &&
+ detail::compute_equal<T, std::numeric_limits<T>::is_iec559>::call(v1.w, v2.w);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_nequal
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return !compute_vec4_equal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+ }
+ };
+
+ template<typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
+ struct compute_vec4_bitwise_not
+ {
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(~v.x, ~v.y, ~v.z, ~v.w);
+ }
+ };
+}//namespace detail
+
+ // -- Implicit basic constructors --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec()
+# if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
+ : x(0), y(0), z(0), w(0)
+# endif
+ {}
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, Q> const& v)
+ : x(v.x), y(v.y), z(v.z), w(v.w)
+ {}
+# endif
+
+ template<typename T, qualifier Q>
+ template<qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, P> const& v)
+ : x(v.x), y(v.y), z(v.z), w(v.w)
+ {}
+
+ // -- Explicit basic constructors --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T scalar)
+ : x(scalar), y(scalar), z(scalar), w(scalar)
+ {}
+
+ template <typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(T _x, T _y, T _z, T _w)
+ : x(_x), y(_y), z(_z), w(_w)
+ {}
+
+ // -- Conversion scalar constructors --
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.x))
+ , z(static_cast<T>(v.x))
+ , w(static_cast<T>(v.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, Z _z, W _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, W _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, W _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, W _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, W _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, W _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, W _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, Z _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, Z _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, Y _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(X _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename X, typename Y, typename Z, typename W>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, X, Q> const& _x, vec<1, Y, Q> const& _y, vec<1, Z, Q> const& _z, vec<1, W, Q> const& _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ // -- Conversion vector constructors --
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, C _w)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, C _w)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, B _z, vec<1, C, P> const& _w)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<1, B, P> const& _z, vec<1, C, P> const& _w)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_z.x))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, C _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, C _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<2, B, P> const& _yz, vec<1, C, P> const& _w)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_yz.x))
+ , z(static_cast<T>(_yz.y))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, B _y, vec<2, C, P> const& _zw)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_zw.x))
+ , w(static_cast<T>(_zw.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, B _y, vec<2, C, P> const& _zw)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y))
+ , z(static_cast<T>(_zw.x))
+ , w(static_cast<T>(_zw.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_zw.x))
+ , w(static_cast<T>(_zw.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, typename C, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y, vec<2, C, P> const& _zw)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_y.x))
+ , z(static_cast<T>(_zw.x))
+ , w(static_cast<T>(_zw.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, B _w)
+ : x(static_cast<T>(_xyz.x))
+ , y(static_cast<T>(_xyz.y))
+ , z(static_cast<T>(_xyz.z))
+ , w(static_cast<T>(_w))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<3, A, P> const& _xyz, vec<1, B, P> const& _w)
+ : x(static_cast<T>(_xyz.x))
+ , y(static_cast<T>(_xyz.y))
+ , z(static_cast<T>(_xyz.z))
+ , w(static_cast<T>(_w.x))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(A _x, vec<3, B, P> const& _yzw)
+ : x(static_cast<T>(_x))
+ , y(static_cast<T>(_yzw.x))
+ , z(static_cast<T>(_yzw.y))
+ , w(static_cast<T>(_yzw.z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<1, A, P> const& _x, vec<3, B, P> const& _yzw)
+ : x(static_cast<T>(_x.x))
+ , y(static_cast<T>(_yzw.x))
+ , z(static_cast<T>(_yzw.y))
+ , w(static_cast<T>(_yzw.z))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename A, typename B, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<2, A, P> const& _xy, vec<2, B, P> const& _zw)
+ : x(static_cast<T>(_xy.x))
+ , y(static_cast<T>(_xy.y))
+ , z(static_cast<T>(_zw.x))
+ , w(static_cast<T>(_zw.y))
+ {}
+
+ template<typename T, qualifier Q>
+ template<typename U, qualifier P>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, U, P> const& v)
+ : x(static_cast<T>(v.x))
+ , y(static_cast<T>(v.y))
+ , z(static_cast<T>(v.z))
+ , w(static_cast<T>(v.w))
+ {}
+
+ // -- Component accesses --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i)
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ case 2:
+ return z;
+ case 3:
+ return w;
+ }
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& vec<4, T, Q>::operator[](typename vec<4, T, Q>::length_type i) const
+ {
+ assert(i >= 0 && i < this->length());
+ switch(i)
+ {
+ default:
+ case 0:
+ return x;
+ case 1:
+ return y;
+ case 2:
+ return z;
+ case 3:
+ return w;
+ }
+ }
+
+ // -- Unary arithmetic operators --
+
+# if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v)
+ {
+ this->x = v.x;
+ this->y = v.y;
+ this->z = v.z;
+ this->w = v.w;
+ return *this;
+ }
+# endif
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, U, Q> const& v)
+ {
+ this->x = static_cast<T>(v.x);
+ this->y = static_cast<T>(v.y);
+ this->z = static_cast<T>(v.z);
+ this->w = static_cast<T>(v.w);
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(U scalar)
+ {
+ return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator+=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(U scalar)
+ {
+ return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator-=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_sub<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(U scalar)
+ {
+ return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator*=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(U scalar)
+ {
+ return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v.x)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator/=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_div<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ // -- Increment and decrement operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator++()
+ {
+ ++this->x;
+ ++this->y;
+ ++this->z;
+ ++this->w;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator--()
+ {
+ --this->x;
+ --this->y;
+ --this->z;
+ --this->w;
+ return *this;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator++(int)
+ {
+ vec<4, T, Q> Result(*this);
+ ++*this;
+ return Result;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> vec<4, T, Q>::operator--(int)
+ {
+ vec<4, T, Q> Result(*this);
+ --*this;
+ return Result;
+ }
+
+ // -- Unary bit operators --
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(U scalar)
+ {
+ return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator%=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_mod<T, Q, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(U scalar)
+ {
+ return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator&=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_and<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(U scalar)
+ {
+ return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator|=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_or<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(U scalar)
+ {
+ return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator^=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_xor<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(U scalar)
+ {
+ return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator<<=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_shift_left<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(U scalar)
+ {
+ return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(scalar)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<1, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ template<typename T, qualifier Q>
+ template<typename U>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> & vec<4, T, Q>::operator>>=(vec<4, U, Q> const& v)
+ {
+ return (*this = detail::compute_vec4_shift_right<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(*this, vec<4, T, Q>(v)));
+ }
+
+ // -- Unary constant operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v)
+ {
+ return v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(0) -= v;
+ }
+
+ // -- Binary arithmetic operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v, T const & scalar)
+ {
+ return vec<4, T, Q>(v) += scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) += v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(v) += scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v2) += v1;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator+(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) += v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v, T const & scalar)
+ {
+ return vec<4, T, Q>(v) -= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) -= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) -= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) -= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator-(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) -= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v, T const & scalar)
+ {
+ return vec<4, T, Q>(v) *= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) *= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(v) *= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v2) *= v1;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator*(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) *= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v, T const & scalar)
+ {
+ return vec<4, T, Q>(v) /= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) /= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) /= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) /= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator/(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) /= v2;
+ }
+
+ // -- Binary bit operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) %= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) %= v2.x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) %= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<1, T, Q> const& scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar.x) %= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator%(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) %= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) &= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v, vec<1, T, Q> const& scalar)
+ {
+ return vec<4, T, Q>(v) &= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) &= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) &= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator&(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) &= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) |= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) |= v2.x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) |= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) |= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator|(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) |= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) ^= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) ^= v2.x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) ^= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) ^= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator^(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) ^= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) <<= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) <<= v2.x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) <<= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) <<= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator<<(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) <<= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v, T scalar)
+ {
+ return vec<4, T, Q>(v) >>= scalar;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<1, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) >>= v2.x;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(T scalar, vec<4, T, Q> const& v)
+ {
+ return vec<4, T, Q>(scalar) >>= v;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<1, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1.x) >>= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator>>(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return vec<4, T, Q>(v1) >>= v2;
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q> operator~(vec<4, T, Q> const& v)
+ {
+ return detail::compute_vec4_bitwise_not<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v);
+ }
+
+ // -- Boolean operators --
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return detail::compute_vec4_equal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+ }
+
+ template<typename T, qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(vec<4, T, Q> const& v1, vec<4, T, Q> const& v2)
+ {
+ return detail::compute_vec4_nequal<T, Q, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<Q>::value>::call(v1, v2);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator&&(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2)
+ {
+ return vec<4, bool, Q>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w);
+ }
+
+ template<qualifier Q>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> operator||(vec<4, bool, Q> const& v1, vec<4, bool, Q> const& v2)
+ {
+ return vec<4, bool, Q>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w);
+ }
+}//namespace glm
+
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+# include "type_vec4_simd.inl"
+#endif
diff --git a/src/include/glm/detail/type_vec4_simd.inl b/src/include/glm/detail/type_vec4_simd.inl new file mode 100644 index 0000000..65022be --- /dev/null +++ b/src/include/glm/detail/type_vec4_simd.inl @@ -0,0 +1,775 @@ +#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+namespace glm{
+namespace detail
+{
+# if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+ template<qualifier Q, int E0, int E1, int E2, int E3>
+ struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
+ {
+ GLM_FUNC_QUALIFIER vec<4, float, Q> operator ()() const
+ {
+ __m128 data = *reinterpret_cast<__m128 const*>(&this->_buffer);
+
+ vec<4, float, Q> Result;
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ Result.data = _mm_permute_ps(data, _MM_SHUFFLE(E3, E2, E1, E0));
+# else
+ Result.data = _mm_shuffle_ps(data, data, _MM_SHUFFLE(E3, E2, E1, E0));
+# endif
+ return Result;
+ }
+ };
+
+ template<qualifier Q, int E0, int E1, int E2, int E3>
+ struct _swizzle_base1<4, int, Q, E0,E1,E2,E3, true> : public _swizzle_base0<int, 4>
+ {
+ GLM_FUNC_QUALIFIER vec<4, int, Q> operator ()() const
+ {
+ __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+ vec<4, int, Q> Result;
+ Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+ return Result;
+ }
+ };
+
+ template<qualifier Q, int E0, int E1, int E2, int E3>
+ struct _swizzle_base1<4, uint, Q, E0,E1,E2,E3, true> : public _swizzle_base0<uint, 4>
+ {
+ GLM_FUNC_QUALIFIER vec<4, uint, Q> operator ()() const
+ {
+ __m128i data = *reinterpret_cast<__m128i const*>(&this->_buffer);
+
+ vec<4, uint, Q> Result;
+ Result.data = _mm_shuffle_epi32(data, _MM_SHUFFLE(E3, E2, E1, E0));
+ return Result;
+ }
+ };
+# endif// GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+ template<qualifier Q>
+ struct compute_vec4_add<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_add_ps(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_vec4_add<double, Q, true>
+ {
+ static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+ {
+ vec<4, double, Q> Result;
+ Result.data = _mm256_add_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_vec4_sub<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_sub_ps(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_vec4_sub<double, Q, true>
+ {
+ static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+ {
+ vec<4, double, Q> Result;
+ Result.data = _mm256_sub_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_vec4_mul<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_mul_ps(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_vec4_mul<double, Q, true>
+ {
+ static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+ {
+ vec<4, double, Q> Result;
+ Result.data = _mm256_mul_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_vec4_div<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = _mm_div_ps(a.data, b.data);
+ return Result;
+ }
+ };
+
+ # if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<qualifier Q>
+ struct compute_vec4_div<double, Q, true>
+ {
+ static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
+ {
+ vec<4, double, Q> Result;
+ Result.data = _mm256_div_pd(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<>
+ struct compute_vec4_div<float, aligned_lowp, true>
+ {
+ static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b)
+ {
+ vec<4, float, aligned_lowp> Result;
+ Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data));
+ return Result;
+ }
+ };
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_and<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_and_si128(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_and<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_and_si256(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_or<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_or_si128(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_or<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_or_si256(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_xor<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_xor_si128(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_xor<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_xor_si256(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_shift_left<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_sll_epi32(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_shift_left<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_sll_epi64(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_shift_right<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_srl_epi32(a.data, b.data);
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_shift_right<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_srl_epi64(a.data, b.data);
+ return Result;
+ }
+ };
+# endif
+
+ template<typename T, qualifier Q>
+ struct compute_vec4_bitwise_not<T, Q, true, 32, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& v)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
+ return Result;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<typename T, qualifier Q>
+ struct compute_vec4_bitwise_not<T, Q, true, 64, true>
+ {
+ static vec<4, T, Q> call(vec<4, T, Q> const& v)
+ {
+ vec<4, T, Q> Result;
+ Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
+ return Result;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_vec4_equal<float, Q, false, 32, true>
+ {
+ static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ return _mm_movemask_ps(_mm_cmpeq_ps(v1.data, v2.data)) != 0;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_SSE41_BIT
+ template<qualifier Q>
+ struct compute_vec4_equal<int, Q, true, 32, true>
+ {
+ static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ //return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0;
+ __m128i neq = _mm_xor_si128(v1.data, v2.data);
+ return _mm_test_all_zeros(neq, neq) == 0;
+ }
+ };
+# endif
+
+ template<qualifier Q>
+ struct compute_vec4_nequal<float, Q, false, 32, true>
+ {
+ static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0;
+ }
+ };
+
+# if GLM_ARCH & GLM_ARCH_SSE41_BIT
+ template<qualifier Q>
+ struct compute_vec4_nequal<int, Q, true, 32, true>
+ {
+ static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ //return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0;
+ __m128i neq = _mm_xor_si128(v1.data, v2.data);
+ return _mm_test_all_zeros(neq, neq) != 0;
+ }
+ };
+# endif
+}//namespace detail
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) :
+ data(_mm_set1_ps(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) :
+ data(_mm_set1_ps(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) :
+ data(_mm_set1_ps(_s))
+ {}
+
+# if GLM_ARCH & GLM_ARCH_AVX_BIT
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_lowp>::vec(double _s) :
+ data(_mm256_set1_pd(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_mediump>::vec(double _s) :
+ data(_mm256_set1_pd(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, double, aligned_highp>::vec(double _s) :
+ data(_mm256_set1_pd(_s))
+ {}
+# endif
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) :
+ data(_mm_set1_epi32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) :
+ data(_mm_set1_epi32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) :
+ data(_mm_set1_epi32(_s))
+ {}
+
+# if GLM_ARCH & GLM_ARCH_AVX2_BIT
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_lowp>::vec(detail::int64 _s) :
+ data(_mm256_set1_epi64x(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_mediump>::vec(detail::int64 _s) :
+ data(_mm256_set1_epi64x(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, detail::int64, aligned_highp>::vec(detail::int64 _s) :
+ data(_mm256_set1_epi64x(_s))
+ {}
+# endif
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _x, float _y, float _z, float _w) :
+ data(_mm_set_ps(_w, _z, _y, _x))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _x, float _y, float _z, float _w) :
+ data(_mm_set_ps(_w, _z, _y, _x))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _x, float _y, float _z, float _w) :
+ data(_mm_set_ps(_w, _z, _y, _x))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_set_epi32(_w, _z, _y, _x))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_set_epi32(_w, _z, _y, _x))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_set_epi32(_w, _z, _y, _x))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+ data(_mm_cvtepi32_ps(_mm_set_epi32(_w, _z, _y, _x)))
+ {}
+}//namespace glm
+
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+#if GLM_ARCH & GLM_ARCH_NEON_BIT
+namespace glm {
+namespace detail {
+
+ template<qualifier Q>
+ struct compute_vec4_add<float, Q, true>
+ {
+ static
+ vec<4, float, Q>
+ call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = vaddq_f32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_add<uint, Q, true>
+ {
+ static
+ vec<4, uint, Q>
+ call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+ {
+ vec<4, uint, Q> Result;
+ Result.data = vaddq_u32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_add<int, Q, true>
+ {
+ static
+ vec<4, int, Q>
+ call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+ {
+ vec<4, uint, Q> Result;
+ Result.data = vaddq_s32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_sub<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = vsubq_f32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_sub<uint, Q, true>
+ {
+ static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+ {
+ vec<4, uint, Q> Result;
+ Result.data = vsubq_u32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_sub<int, Q, true>
+ {
+ static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+ {
+ vec<4, int, Q> Result;
+ Result.data = vsubq_s32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_mul<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = vmulq_f32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_mul<uint, Q, true>
+ {
+ static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
+ {
+ vec<4, uint, Q> Result;
+ Result.data = vmulq_u32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_mul<int, Q, true>
+ {
+ static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
+ {
+ vec<4, int, Q> Result;
+ Result.data = vmulq_s32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_div<float, Q, true>
+ {
+ static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
+ {
+ vec<4, float, Q> Result;
+ Result.data = vdivq_f32(a.data, b.data);
+ return Result;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_equal<float, Q, false, 32, true>
+ {
+ static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ uint32x4_t cmp = vceqq_f32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+ cmp = vpminq_u32(cmp, cmp);
+ cmp = vpminq_u32(cmp, cmp);
+ uint32_t r = cmp[0];
+#else
+ uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+ cmpx2 = vpmin_u32(cmpx2, cmpx2);
+ uint32_t r = cmpx2[0];
+#endif
+ return r == ~0u;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_equal<uint, Q, false, 32, true>
+ {
+ static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+ {
+ uint32x4_t cmp = vceqq_u32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+ cmp = vpminq_u32(cmp, cmp);
+ cmp = vpminq_u32(cmp, cmp);
+ uint32_t r = cmp[0];
+#else
+ uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+ cmpx2 = vpmin_u32(cmpx2, cmpx2);
+ uint32_t r = cmpx2[0];
+#endif
+ return r == ~0u;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_equal<int, Q, false, 32, true>
+ {
+ static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ uint32x4_t cmp = vceqq_s32(v1.data, v2.data);
+#if GLM_ARCH & GLM_ARCH_ARMV8_BIT
+ cmp = vpminq_u32(cmp, cmp);
+ cmp = vpminq_u32(cmp, cmp);
+ uint32_t r = cmp[0];
+#else
+ uint32x2_t cmpx2 = vpmin_u32(vget_low_f32(cmp), vget_high_f32(cmp));
+ cmpx2 = vpmin_u32(cmpx2, cmpx2);
+ uint32_t r = cmpx2[0];
+#endif
+ return r == ~0u;
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_nequal<float, Q, false, 32, true>
+ {
+ static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
+ {
+ return !compute_vec4_equal<float, Q, false, 32, true>::call(v1, v2);
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_nequal<uint, Q, false, 32, true>
+ {
+ static bool call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
+ {
+ return !compute_vec4_equal<uint, Q, false, 32, true>::call(v1, v2);
+ }
+ };
+
+ template<qualifier Q>
+ struct compute_vec4_nequal<int, Q, false, 32, true>
+ {
+ static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
+ {
+ return !compute_vec4_equal<int, Q, false, 32, true>::call(v1, v2);
+ }
+ };
+
+}//namespace detail
+
+#if !GLM_CONFIG_XYZW_ONLY
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(float _s) :
+ data(vdupq_n_f32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(float _s) :
+ data(vdupq_n_f32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(float _s) :
+ data(vdupq_n_f32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_lowp>::vec(int _s) :
+ data(vdupq_n_s32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_mediump>::vec(int _s) :
+ data(vdupq_n_s32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, int, aligned_highp>::vec(int _s) :
+ data(vdupq_n_s32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_lowp>::vec(uint _s) :
+ data(vdupq_n_u32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_mediump>::vec(uint _s) :
+ data(vdupq_n_u32(_s))
+ {}
+
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, uint, aligned_highp>::vec(uint _s) :
+ data(vdupq_n_u32(_s))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, float, aligned_highp>& rhs) :
+ data(rhs.data)
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, int, aligned_highp>& rhs) :
+ data(vcvtq_f32_s32(rhs.data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(const vec<4, uint, aligned_highp>& rhs) :
+ data(vcvtq_f32_u32(rhs.data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(int _x, int _y, int _z, int _w) :
+ data(vcvtq_f32_s32(vec<4, int, aligned_lowp>(_x, _y, _z, _w).data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(int _x, int _y, int _z, int _w) :
+ data(vcvtq_f32_s32(vec<4, int, aligned_mediump>(_x, _y, _z, _w).data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(int _x, int _y, int _z, int _w) :
+ data(vcvtq_f32_s32(vec<4, int, aligned_highp>(_x, _y, _z, _w).data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_lowp>::vec(uint _x, uint _y, uint _z, uint _w) :
+ data(vcvtq_f32_u32(vec<4, uint, aligned_lowp>(_x, _y, _z, _w).data))
+ {}
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_mediump>::vec(uint _x, uint _y, uint _z, uint _w) :
+ data(vcvtq_f32_u32(vec<4, uint, aligned_mediump>(_x, _y, _z, _w).data))
+ {}
+
+
+ template<>
+ template<>
+ GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, float, aligned_highp>::vec(uint _x, uint _y, uint _z, uint _w) :
+ data(vcvtq_f32_u32(vec<4, uint, aligned_highp>(_x, _y, _z, _w).data))
+ {}
+
+#endif
+}//namespace glm
+
+#endif
|