keyword stringclasses 7 values | repo_name stringlengths 8 98 | file_path stringlengths 4 244 | file_extension stringclasses 29 values | file_size int64 0 84.1M | line_count int64 0 1.6M | content stringlengths 1 84.1M ⌀ | language stringclasses 14 values |
|---|---|---|---|---|---|---|---|
3D | mcellteam/mcell | libs/glm/gtx/extended_min_max.hpp | .hpp | 5,800 | 183 | /// @ref gtx_extended_min_max
/// @file glm/gtx/extended_min_max.hpp
///
/// @see core (dependence)
///
/// @defgroup gtx_extended_min_max GLM_GTX_extented_min_max
/// @ingroup gtx
///
/// Include <glm/gtx/extented_min_max.hpp> to use the features of this extension.
///
/// Min and max functions for 3 to 4 parameters.
#pragma once
// Dependency:
#include "../glm.hpp"
#ifndef GLM_ENABLE_EXPERIMENTAL
# error "GLM: GLM_GTX_extented_min_max is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
#endif
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTX_extented_min_max extension included")
#endif
namespace glm
{
/// @addtogroup gtx_extended_min_max
/// @{
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T>
GLM_FUNC_DECL T min(
T const& x,
T const& y,
T const& z);
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> const& x,
typename C<T>::T const& y,
typename C<T>::T const& z);
/// Return the minimum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> const& x,
C<T> const& y,
C<T> const& z);
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T>
GLM_FUNC_DECL T min(
T const& x,
T const& y,
T const& z,
T const& w);
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> const& x,
typename C<T>::T const& y,
typename C<T>::T const& z,
typename C<T>::T const& w);
/// Return the minimum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> min(
C<T> const& x,
C<T> const& y,
C<T> const& z,
C<T> const& w);
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T>
GLM_FUNC_DECL T max(
T const& x,
T const& y,
T const& z);
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> const& x,
typename C<T>::T const& y,
typename C<T>::T const& z);
/// Return the maximum component-wise values of 3 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> const& x,
C<T> const& y,
C<T> const& z);
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T>
GLM_FUNC_DECL T max(
T const& x,
T const& y,
T const& z,
T const& w);
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> const& x,
typename C<T>::T const& y,
typename C<T>::T const& z,
typename C<T>::T const& w);
/// Return the maximum component-wise values of 4 inputs
/// @see gtx_extented_min_max
template<typename T, template<typename> class C>
GLM_FUNC_DECL C<T> max(
C<T> const& x,
C<T> const& y,
C<T> const& z,
C<T> const& w);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see gtx_extented_min_max
template<typename genType>
GLM_FUNC_DECL genType fmin(genType x, genType y);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point; scalar or vector types.
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<typename genType>
GLM_FUNC_DECL genType fmax(genType x, genType y);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see gtx_extented_min_max
template<typename genType>
GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
/// @}
}//namespace glm
#include "extended_min_max.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/gtx/scalar_multiplication.hpp | .hpp | 2,330 | 76 | /// @ref gtx
/// @file glm/gtx/scalar_multiplication.hpp
/// @author Joshua Moerman
///
/// Include <glm/gtx/scalar_multiplication.hpp> to use the features of this extension.
///
/// Enables scalar multiplication for all types
///
/// Since GLSL is very strict about types, the following (often used) combinations do not work:
/// double * vec4
/// int * vec4
/// vec4 / int
/// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic)
#pragma once
#include "../detail/setup.hpp"
#ifndef GLM_ENABLE_EXPERIMENTAL
# error "GLM: GLM_GTX_scalar_multiplication is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
#endif
#if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC)
# error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC"
#endif
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../mat2x2.hpp"
#include <type_traits>
namespace glm
{
template<typename T, typename Vec>
using return_type_scalar_multiplication = typename std::enable_if<
!std::is_same<T, float>::value // T may not be a float
&& std::is_arithmetic<T>::value, Vec // But it may be an int or double (no vec3 or mat3, ...)
>::type;
#define GLM_IMPLEMENT_SCAL_MULT(Vec) \
template<typename T> \
return_type_scalar_multiplication<T, Vec> \
operator*(T const& s, Vec rh){ \
return rh *= static_cast<float>(s); \
} \
\
template<typename T> \
return_type_scalar_multiplication<T, Vec> \
operator*(Vec lh, T const& s){ \
return lh *= static_cast<float>(s); \
} \
\
template<typename T> \
return_type_scalar_multiplication<T, Vec> \
operator/(Vec lh, T const& s){ \
return lh *= 1.0f / s; \
}
GLM_IMPLEMENT_SCAL_MULT(vec2)
GLM_IMPLEMENT_SCAL_MULT(vec3)
GLM_IMPLEMENT_SCAL_MULT(vec4)
GLM_IMPLEMENT_SCAL_MULT(mat2)
GLM_IMPLEMENT_SCAL_MULT(mat2x3)
GLM_IMPLEMENT_SCAL_MULT(mat2x4)
GLM_IMPLEMENT_SCAL_MULT(mat3x2)
GLM_IMPLEMENT_SCAL_MULT(mat3)
GLM_IMPLEMENT_SCAL_MULT(mat3x4)
GLM_IMPLEMENT_SCAL_MULT(mat4x2)
GLM_IMPLEMENT_SCAL_MULT(mat4x3)
GLM_IMPLEMENT_SCAL_MULT(mat4)
#undef GLM_IMPLEMENT_SCAL_MULT
} // namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/gtx/vec_swizzle.hpp | .hpp | 78,881 | 2,779 | /// @ref gtx_vec_swizzle
/// @file glm/gtx/vec_swizzle.hpp
///
/// @see core (dependence)
///
/// @defgroup gtx_vec_swizzle GLM_GTX_vec_swizzle
/// @ingroup gtx
///
/// Include <glm/gtx/vec_swizzle.hpp> to use the features of this extension.
///
/// Functions to perform swizzle operation.
#pragma once
#include "../glm.hpp"
#ifndef GLM_ENABLE_EXPERIMENTAL
# error "GLM: GLM_GTX_vec_swizzle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."
#endif
namespace glm {
// xx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<1, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<2, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xx(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.x);
}
// xy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<2, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xy(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.y);
}
// xz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xz(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.z);
}
// xw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> xw(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.x, v.w);
}
// yx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<2, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yx(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.x);
}
// yy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<2, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yy(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.y);
}
// yz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yz(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.z);
}
// yw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> yw(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.y, v.w);
}
// zx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zx(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.x);
}
// zy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zy(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.y);
}
// zz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<3, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zz(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.z);
}
// zw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> zw(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.z, v.w);
}
// wx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> wx(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.w, v.x);
}
// wy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> wy(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.w, v.y);
}
// wz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> wz(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.w, v.z);
}
// ww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<2, T, Q> ww(const glm::vec<4, T, Q> &v) {
return glm::vec<2, T, Q>(v.w, v.w);
}
// xxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<1, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.x);
}
// xxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.y);
}
// xxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.z);
}
// xxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xxw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.x, v.w);
}
// xyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.x);
}
// xyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.y);
}
// xyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.z);
}
// xyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xyw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.y, v.w);
}
// xzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.x);
}
// xzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.y);
}
// xzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.z);
}
// xzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xzw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.z, v.w);
}
// xwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xwx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.w, v.x);
}
// xwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xwy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.w, v.y);
}
// xwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xwz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.w, v.z);
}
// xww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> xww(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.x, v.w, v.w);
}
// yxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.x);
}
// yxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.y);
}
// yxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.z);
}
// yxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yxw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.x, v.w);
}
// yyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.x);
}
// yyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<2, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.y);
}
// yyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.z);
}
// yyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yyw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.y, v.w);
}
// yzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.x);
}
// yzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.y);
}
// yzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.z);
}
// yzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yzw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.z, v.w);
}
// ywx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> ywx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.w, v.x);
}
// ywy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> ywy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.w, v.y);
}
// ywz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> ywz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.w, v.z);
}
// yww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> yww(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.y, v.w, v.w);
}
// zxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.x);
}
// zxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.y);
}
// zxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.z);
}
// zxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zxw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.x, v.w);
}
// zyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.x);
}
// zyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.y);
}
// zyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.z);
}
// zyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zyw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.y, v.w);
}
// zzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.x);
}
// zzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.y);
}
// zzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<3, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.z);
}
// zzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zzw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.z, v.w);
}
// zwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zwx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.w, v.x);
}
// zwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zwy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.w, v.y);
}
// zwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zwz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.w, v.z);
}
// zww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> zww(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.z, v.w, v.w);
}
// wxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wxx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.x, v.x);
}
// wxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wxy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.x, v.y);
}
// wxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wxz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.x, v.z);
}
// wxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wxw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.x, v.w);
}
// wyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wyx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.y, v.x);
}
// wyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wyy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.y, v.y);
}
// wyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wyz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.y, v.z);
}
// wyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wyw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.y, v.w);
}
// wzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wzx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.z, v.x);
}
// wzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wzy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.z, v.y);
}
// wzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wzz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.z, v.z);
}
// wzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wzw(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.z, v.w);
}
// wwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wwx(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.w, v.x);
}
// wwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wwy(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.w, v.y);
}
// wwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> wwz(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.w, v.z);
}
// www
template<typename T, qualifier Q>
GLM_INLINE glm::vec<3, T, Q> www(const glm::vec<4, T, Q> &v) {
return glm::vec<3, T, Q>(v.w, v.w, v.w);
}
// xxxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<1, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
}
// xxxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
}
// xxxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
}
// xxxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.x, v.w);
}
// xxyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
}
// xxyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
}
// xxyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
}
// xxyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.y, v.w);
}
// xxzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
}
// xxzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
}
// xxzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
}
// xxzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.z, v.w);
}
// xxwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.w, v.x);
}
// xxwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.w, v.y);
}
// xxwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.w, v.z);
}
// xxww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xxww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.x, v.w, v.w);
}
// xyxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
}
// xyxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
}
// xyxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
}
// xyxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.x, v.w);
}
// xyyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
}
// xyyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
}
// xyyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
}
// xyyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.y, v.w);
}
// xyzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
}
// xyzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
}
// xyzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
}
// xyzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.z, v.w);
}
// xywx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xywx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.w, v.x);
}
// xywy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xywy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.w, v.y);
}
// xywz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xywz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.w, v.z);
}
// xyww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xyww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.y, v.w, v.w);
}
// xzxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
}
// xzxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
}
// xzxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
}
// xzxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.x, v.w);
}
// xzyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
}
// xzyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
}
// xzyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
}
// xzyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.y, v.w);
}
// xzzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
}
// xzzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
}
// xzzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
}
// xzzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.z, v.w);
}
// xzwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.w, v.x);
}
// xzwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.w, v.y);
}
// xzwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.w, v.z);
}
// xzww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xzww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.z, v.w, v.w);
}
// xwxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.x, v.x);
}
// xwxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.x, v.y);
}
// xwxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.x, v.z);
}
// xwxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.x, v.w);
}
// xwyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.y, v.x);
}
// xwyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.y, v.y);
}
// xwyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.y, v.z);
}
// xwyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.y, v.w);
}
// xwzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.z, v.x);
}
// xwzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.z, v.y);
}
// xwzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.z, v.z);
}
// xwzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.z, v.w);
}
// xwwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.w, v.x);
}
// xwwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.w, v.y);
}
// xwwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.w, v.z);
}
// xwww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> xwww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.x, v.w, v.w, v.w);
}
// yxxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
}
// yxxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
}
// yxxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
}
// yxxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.x, v.w);
}
// yxyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
}
// yxyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
}
// yxyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
}
// yxyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.y, v.w);
}
// yxzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
}
// yxzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
}
// yxzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
}
// yxzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.z, v.w);
}
// yxwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.w, v.x);
}
// yxwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.w, v.y);
}
// yxwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.w, v.z);
}
// yxww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yxww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.x, v.w, v.w);
}
// yyxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
}
// yyxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
}
// yyxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
}
// yyxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.x, v.w);
}
// yyyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
}
// yyyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<2, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
}
// yyyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
}
// yyyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.y, v.w);
}
// yyzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
}
// yyzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
}
// yyzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
}
// yyzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.z, v.w);
}
// yywx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yywx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.w, v.x);
}
// yywy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yywy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.w, v.y);
}
// yywz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yywz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.w, v.z);
}
// yyww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yyww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.y, v.w, v.w);
}
// yzxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
}
// yzxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
}
// yzxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
}
// yzxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.x, v.w);
}
// yzyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
}
// yzyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
}
// yzyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
}
// yzyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.y, v.w);
}
// yzzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
}
// yzzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
}
// yzzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
}
// yzzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.z, v.w);
}
// yzwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.w, v.x);
}
// yzwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.w, v.y);
}
// yzwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.w, v.z);
}
// yzww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> yzww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.z, v.w, v.w);
}
// ywxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.x, v.x);
}
// ywxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.x, v.y);
}
// ywxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.x, v.z);
}
// ywxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.x, v.w);
}
// ywyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.y, v.x);
}
// ywyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.y, v.y);
}
// ywyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.y, v.z);
}
// ywyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.y, v.w);
}
// ywzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.z, v.x);
}
// ywzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.z, v.y);
}
// ywzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.z, v.z);
}
// ywzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.z, v.w);
}
// ywwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.w, v.x);
}
// ywwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.w, v.y);
}
// ywwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.w, v.z);
}
// ywww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> ywww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.y, v.w, v.w, v.w);
}
// zxxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
}
// zxxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
}
// zxxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
}
// zxxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.x, v.w);
}
// zxyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
}
// zxyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
}
// zxyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
}
// zxyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.y, v.w);
}
// zxzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
}
// zxzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
}
// zxzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
}
// zxzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.z, v.w);
}
// zxwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.w, v.x);
}
// zxwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.w, v.y);
}
// zxwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.w, v.z);
}
// zxww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zxww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.x, v.w, v.w);
}
// zyxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
}
// zyxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
}
// zyxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
}
// zyxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.x, v.w);
}
// zyyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
}
// zyyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
}
// zyyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
}
// zyyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.y, v.w);
}
// zyzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
}
// zyzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
}
// zyzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
}
// zyzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.z, v.w);
}
// zywx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zywx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.w, v.x);
}
// zywy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zywy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.w, v.y);
}
// zywz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zywz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.w, v.z);
}
// zyww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zyww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.y, v.w, v.w);
}
// zzxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
}
// zzxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
}
// zzxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
}
// zzxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.x, v.w);
}
// zzyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
}
// zzyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
}
// zzyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
}
// zzyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.y, v.w);
}
// zzzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
}
// zzzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
}
// zzzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<3, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
}
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
}
// zzzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.z, v.w);
}
// zzwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.w, v.x);
}
// zzwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.w, v.y);
}
// zzwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.w, v.z);
}
// zzww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zzww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.z, v.w, v.w);
}
// zwxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.x, v.x);
}
// zwxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.x, v.y);
}
// zwxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.x, v.z);
}
// zwxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.x, v.w);
}
// zwyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.y, v.x);
}
// zwyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.y, v.y);
}
// zwyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.y, v.z);
}
// zwyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.y, v.w);
}
// zwzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.z, v.x);
}
// zwzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.z, v.y);
}
// zwzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.z, v.z);
}
// zwzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.z, v.w);
}
// zwwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.w, v.x);
}
// zwwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.w, v.y);
}
// zwwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.w, v.z);
}
// zwww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> zwww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.z, v.w, v.w, v.w);
}
// wxxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.x, v.x);
}
// wxxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.x, v.y);
}
// wxxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.x, v.z);
}
// wxxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.x, v.w);
}
// wxyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.y, v.x);
}
// wxyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.y, v.y);
}
// wxyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.y, v.z);
}
// wxyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.y, v.w);
}
// wxzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.z, v.x);
}
// wxzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.z, v.y);
}
// wxzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.z, v.z);
}
// wxzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.z, v.w);
}
// wxwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.w, v.x);
}
// wxwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.w, v.y);
}
// wxwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.w, v.z);
}
// wxww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wxww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.x, v.w, v.w);
}
// wyxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.x, v.x);
}
// wyxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.x, v.y);
}
// wyxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.x, v.z);
}
// wyxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.x, v.w);
}
// wyyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.y, v.x);
}
// wyyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.y, v.y);
}
// wyyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.y, v.z);
}
// wyyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.y, v.w);
}
// wyzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.z, v.x);
}
// wyzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.z, v.y);
}
// wyzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.z, v.z);
}
// wyzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.z, v.w);
}
// wywx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wywx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.w, v.x);
}
// wywy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wywy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.w, v.y);
}
// wywz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wywz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.w, v.z);
}
// wyww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wyww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.y, v.w, v.w);
}
// wzxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.x, v.x);
}
// wzxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.x, v.y);
}
// wzxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.x, v.z);
}
// wzxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.x, v.w);
}
// wzyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.y, v.x);
}
// wzyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.y, v.y);
}
// wzyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.y, v.z);
}
// wzyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.y, v.w);
}
// wzzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.z, v.x);
}
// wzzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.z, v.y);
}
// wzzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.z, v.z);
}
// wzzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.z, v.w);
}
// wzwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.w, v.x);
}
// wzwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.w, v.y);
}
// wzwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.w, v.z);
}
// wzww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wzww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.z, v.w, v.w);
}
// wwxx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwxx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.x, v.x);
}
// wwxy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwxy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.x, v.y);
}
// wwxz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwxz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.x, v.z);
}
// wwxw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwxw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.x, v.w);
}
// wwyx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwyx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.y, v.x);
}
// wwyy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwyy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.y, v.y);
}
// wwyz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwyz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.y, v.z);
}
// wwyw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwyw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.y, v.w);
}
// wwzx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwzx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.z, v.x);
}
// wwzy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwzy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.z, v.y);
}
// wwzz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwzz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.z, v.z);
}
// wwzw
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwzw(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.z, v.w);
}
// wwwx
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwwx(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.w, v.x);
}
// wwwy
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwwy(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.w, v.y);
}
// wwwz
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwwz(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.w, v.z);
}
// wwww
template<typename T, qualifier Q>
GLM_INLINE glm::vec<4, T, Q> wwww(const glm::vec<4, T, Q> &v) {
return glm::vec<4, T, Q>(v.w, v.w, v.w, v.w);
}
}
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/matrix.h | .h | 40,979 | 1,029 | /// @ref simd
/// @file glm/simd/matrix.h
#pragma once
#include "geometric.h"
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_QUALIFIER void glm_mat4_matrixCompMult(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
{
out[0] = _mm_mul_ps(in1[0], in2[0]);
out[1] = _mm_mul_ps(in1[1], in2[1]);
out[2] = _mm_mul_ps(in1[2], in2[2]);
out[3] = _mm_mul_ps(in1[3], in2[3]);
}
GLM_FUNC_QUALIFIER void glm_mat4_add(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
{
out[0] = _mm_add_ps(in1[0], in2[0]);
out[1] = _mm_add_ps(in1[1], in2[1]);
out[2] = _mm_add_ps(in1[2], in2[2]);
out[3] = _mm_add_ps(in1[3], in2[3]);
}
GLM_FUNC_QUALIFIER void glm_mat4_sub(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
{
out[0] = _mm_sub_ps(in1[0], in2[0]);
out[1] = _mm_sub_ps(in1[1], in2[1]);
out[2] = _mm_sub_ps(in1[2], in2[2]);
out[3] = _mm_sub_ps(in1[3], in2[3]);
}
GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_mul_vec4(glm_vec4 const m[4], glm_vec4 v)
{
__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
__m128 m0 = _mm_mul_ps(m[0], v0);
__m128 m1 = _mm_mul_ps(m[1], v1);
__m128 m2 = _mm_mul_ps(m[2], v2);
__m128 m3 = _mm_mul_ps(m[3], v3);
__m128 a0 = _mm_add_ps(m0, m1);
__m128 a1 = _mm_add_ps(m2, m3);
__m128 a2 = _mm_add_ps(a0, a1);
return a2;
}
GLM_FUNC_QUALIFIER __m128 glm_vec4_mul_mat4(glm_vec4 v, glm_vec4 const m[4])
{
__m128 i0 = m[0];
__m128 i1 = m[1];
__m128 i2 = m[2];
__m128 i3 = m[3];
__m128 m0 = _mm_mul_ps(v, i0);
__m128 m1 = _mm_mul_ps(v, i1);
__m128 m2 = _mm_mul_ps(v, i2);
__m128 m3 = _mm_mul_ps(v, i3);
__m128 u0 = _mm_unpacklo_ps(m0, m1);
__m128 u1 = _mm_unpackhi_ps(m0, m1);
__m128 a0 = _mm_add_ps(u0, u1);
__m128 u2 = _mm_unpacklo_ps(m2, m3);
__m128 u3 = _mm_unpackhi_ps(m2, m3);
__m128 a1 = _mm_add_ps(u2, u3);
__m128 f0 = _mm_movelh_ps(a0, a1);
__m128 f1 = _mm_movehl_ps(a1, a0);
__m128 f2 = _mm_add_ps(f0, f1);
return f2;
}
GLM_FUNC_QUALIFIER void glm_mat4_mul(glm_vec4 const in1[4], glm_vec4 const in2[4], glm_vec4 out[4])
{
{
__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
__m128 m0 = _mm_mul_ps(in1[0], e0);
__m128 m1 = _mm_mul_ps(in1[1], e1);
__m128 m2 = _mm_mul_ps(in1[2], e2);
__m128 m3 = _mm_mul_ps(in1[3], e3);
__m128 a0 = _mm_add_ps(m0, m1);
__m128 a1 = _mm_add_ps(m2, m3);
__m128 a2 = _mm_add_ps(a0, a1);
out[0] = a2;
}
{
__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 m0 = _mm_mul_ps(in1[0], e0);
__m128 m1 = _mm_mul_ps(in1[1], e1);
__m128 m2 = _mm_mul_ps(in1[2], e2);
__m128 m3 = _mm_mul_ps(in1[3], e3);
__m128 a0 = _mm_add_ps(m0, m1);
__m128 a1 = _mm_add_ps(m2, m3);
__m128 a2 = _mm_add_ps(a0, a1);
out[1] = a2;
}
{
__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 m0 = _mm_mul_ps(in1[0], e0);
__m128 m1 = _mm_mul_ps(in1[1], e1);
__m128 m2 = _mm_mul_ps(in1[2], e2);
__m128 m3 = _mm_mul_ps(in1[3], e3);
__m128 a0 = _mm_add_ps(m0, m1);
__m128 a1 = _mm_add_ps(m2, m3);
__m128 a2 = _mm_add_ps(a0, a1);
out[2] = a2;
}
{
//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
__m128 m0 = _mm_mul_ps(in1[0], e0);
__m128 m1 = _mm_mul_ps(in1[1], e1);
__m128 m2 = _mm_mul_ps(in1[2], e2);
__m128 m3 = _mm_mul_ps(in1[3], e3);
__m128 a0 = _mm_add_ps(m0, m1);
__m128 a1 = _mm_add_ps(m2, m3);
__m128 a2 = _mm_add_ps(a0, a1);
out[3] = a2;
}
}
GLM_FUNC_QUALIFIER void glm_mat4_transpose(glm_vec4 const in[4], glm_vec4 out[4])
{
__m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
__m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
__m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
__m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
}
GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_highp(glm_vec4 const in[4])
{
__m128 Fac0;
{
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
// valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac0 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac1;
{
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
// valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac1 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac2;
{
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
// valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac2 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac3;
{
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
// valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac3 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac4;
{
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
// valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac4 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac5;
{
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
// valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac5 = _mm_sub_ps(Mul00, Mul01);
}
__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
// m[1][0]
// m[0][0]
// m[0][0]
// m[0][0]
__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][1]
// m[0][1]
// m[0][1]
// m[0][1]
__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][2]
// m[0][2]
// m[0][2]
// m[0][2]
__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][3]
// m[0][3]
// m[0][3]
// m[0][3]
__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
// col0
// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
__m128 Add00 = _mm_add_ps(Sub00, Mul02);
__m128 Inv0 = _mm_mul_ps(SignB, Add00);
// col1
// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
__m128 Add01 = _mm_add_ps(Sub01, Mul05);
__m128 Inv1 = _mm_mul_ps(SignA, Add01);
// col2
// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
__m128 Add02 = _mm_add_ps(Sub02, Mul08);
__m128 Inv2 = _mm_mul_ps(SignB, Add02);
// col3
// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
__m128 Add03 = _mm_add_ps(Sub03, Mul11);
__m128 Inv3 = _mm_mul_ps(SignA, Add03);
__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
// valType Determinant = m[0][0] * Inverse[0][0]
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_vec4_dot(in[0], Row2);
return Det0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant_lowp(glm_vec4 const m[4])
{
// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// First 2 columns
__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
// Second 2 columns
__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
// Columns subtraction
__m128 SubE = _mm_sub_ps(MulA, MulB);
// Last 2 rows
__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
//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));
__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
//return m[0][0] * DetCof[0]
// + m[0][1] * DetCof[1]
// + m[0][2] * DetCof[2]
// + m[0][3] * DetCof[3];
return glm_vec4_dot(m[0], DetCof);
}
GLM_FUNC_QUALIFIER glm_vec4 glm_mat4_determinant(glm_vec4 const m[4])
{
// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// First 2 columns
__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
// Second 2 columns
__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
// Columns subtraction
__m128 SubE = _mm_sub_ps(MulA, MulB);
// Last 2 rows
__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
//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));
__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
//return m[0][0] * DetCof[0]
// + m[0][1] * DetCof[1]
// + m[0][2] * DetCof[2]
// + m[0][3] * DetCof[3];
return glm_vec4_dot(m[0], DetCof);
}
GLM_FUNC_QUALIFIER void glm_mat4_inverse(glm_vec4 const in[4], glm_vec4 out[4])
{
__m128 Fac0;
{
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
// valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac0 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac1;
{
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
// valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac1 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac2;
{
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
// valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac2 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac3;
{
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
// valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac3 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac4;
{
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
// valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac4 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac5;
{
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
// valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac5 = _mm_sub_ps(Mul00, Mul01);
}
__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
// m[1][0]
// m[0][0]
// m[0][0]
// m[0][0]
__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][1]
// m[0][1]
// m[0][1]
// m[0][1]
__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][2]
// m[0][2]
// m[0][2]
// m[0][2]
__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][3]
// m[0][3]
// m[0][3]
// m[0][3]
__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
// col0
// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
__m128 Add00 = _mm_add_ps(Sub00, Mul02);
__m128 Inv0 = _mm_mul_ps(SignB, Add00);
// col1
// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
__m128 Add01 = _mm_add_ps(Sub01, Mul05);
__m128 Inv1 = _mm_mul_ps(SignA, Add01);
// col2
// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
__m128 Add02 = _mm_add_ps(Sub02, Mul08);
__m128 Inv2 = _mm_mul_ps(SignB, Add02);
// col3
// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
__m128 Add03 = _mm_add_ps(Sub03, Mul11);
__m128 Inv3 = _mm_mul_ps(SignA, Add03);
__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
// valType Determinant = m[0][0] * Inverse[0][0]
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_vec4_dot(in[0], Row2);
__m128 Rcp0 = _mm_div_ps(_mm_set1_ps(1.0f), Det0);
//__m128 Rcp0 = _mm_rcp_ps(Det0);
// Inverse /= Determinant;
out[0] = _mm_mul_ps(Inv0, Rcp0);
out[1] = _mm_mul_ps(Inv1, Rcp0);
out[2] = _mm_mul_ps(Inv2, Rcp0);
out[3] = _mm_mul_ps(Inv3, Rcp0);
}
GLM_FUNC_QUALIFIER void glm_mat4_inverse_lowp(glm_vec4 const in[4], glm_vec4 out[4])
{
__m128 Fac0;
{
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
// valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
// valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac0 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac1;
{
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
// valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
// valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac1 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac2;
{
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
// valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
// valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac2 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac3;
{
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
// valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
// valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac3 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac4;
{
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
// valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
// valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac4 = _mm_sub_ps(Mul00, Mul01);
}
__m128 Fac5;
{
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
// valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
// valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
Fac5 = _mm_sub_ps(Mul00, Mul01);
}
__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
// m[1][0]
// m[0][0]
// m[0][0]
// m[0][0]
__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][1]
// m[0][1]
// m[0][1]
// m[0][1]
__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][2]
// m[0][2]
// m[0][2]
// m[0][2]
__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
// m[1][3]
// m[0][3]
// m[0][3]
// m[0][3]
__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
// col0
// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
__m128 Add00 = _mm_add_ps(Sub00, Mul02);
__m128 Inv0 = _mm_mul_ps(SignB, Add00);
// col1
// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
__m128 Add01 = _mm_add_ps(Sub01, Mul05);
__m128 Inv1 = _mm_mul_ps(SignA, Add01);
// col2
// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
__m128 Add02 = _mm_add_ps(Sub02, Mul08);
__m128 Inv2 = _mm_mul_ps(SignB, Add02);
// col3
// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
__m128 Add03 = _mm_add_ps(Sub03, Mul11);
__m128 Inv3 = _mm_mul_ps(SignA, Add03);
__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
// valType Determinant = m[0][0] * Inverse[0][0]
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_vec4_dot(in[0], Row2);
__m128 Rcp0 = _mm_rcp_ps(Det0);
//__m128 Rcp0 = _mm_div_ps(one, Det0);
// Inverse /= Determinant;
out[0] = _mm_mul_ps(Inv0, Rcp0);
out[1] = _mm_mul_ps(Inv1, Rcp0);
out[2] = _mm_mul_ps(Inv2, Rcp0);
out[3] = _mm_mul_ps(Inv3, Rcp0);
}
/*
GLM_FUNC_QUALIFIER void glm_mat4_rotate(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
{
float a = glm::radians(Angle);
float c = cos(a);
float s = sin(a);
glm::vec4 AxisA(v[0], v[1], v[2], float(0));
__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
__m128 AxisC = detail::sse_nrm_ps(AxisB);
__m128 Cos0 = _mm_set_ss(c);
__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
__m128 Sin0 = _mm_set_ss(s);
__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
// vec<3, T, Q> temp = (valType(1) - c) * axis;
__m128 Temp0 = _mm_sub_ps(one, CosA);
__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
//Rotate[0][0] = c + temp[0] * axis[0];
//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
//Rotate[1][1] = c + temp[1] * axis[1];
//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
//Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
//Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
//Rotate[2][2] = c + temp[2] * axis[2];
__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
__m128 Result[4];
Result[0] = TmpA4;
Result[1] = TmpB4;
Result[2] = TmpC4;
Result[3] = _mm_set_ps(1, 0, 0, 0);
//mat<4, 4, valType> Result;
//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
//Result[3] = m[3];
//return Result;
sse_mul_ps(in, Result, out);
}
*/
GLM_FUNC_QUALIFIER void glm_mat4_outerProduct(__m128 const& c, __m128 const& r, __m128 out[4])
{
out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
}
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/exponential.h | .h | 397 | 21 | /// @ref simd
/// @file glm/simd/experimental.h
#pragma once
#include "platform.h"
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x)
{
return _mm_mul_ss(_mm_rsqrt_ss(x), x);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x)
{
return _mm_mul_ps(_mm_rsqrt_ps(x), x);
}
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/platform.h | .h | 12,253 | 358 | #pragma once
///////////////////////////////////////////////////////////////////////////////////
// Platform
#define GLM_PLATFORM_UNKNOWN 0x00000000
#define GLM_PLATFORM_WINDOWS 0x00010000
#define GLM_PLATFORM_LINUX 0x00020000
#define GLM_PLATFORM_APPLE 0x00040000
//#define GLM_PLATFORM_IOS 0x00080000
#define GLM_PLATFORM_ANDROID 0x00100000
#define GLM_PLATFORM_CHROME_NACL 0x00200000
#define GLM_PLATFORM_UNIX 0x00400000
#define GLM_PLATFORM_QNXNTO 0x00800000
#define GLM_PLATFORM_WINCE 0x01000000
#define GLM_PLATFORM_CYGWIN 0x02000000
#ifdef GLM_FORCE_PLATFORM_UNKNOWN
# define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
#elif defined(__CYGWIN__)
# define GLM_PLATFORM GLM_PLATFORM_CYGWIN
#elif defined(__QNXNTO__)
# define GLM_PLATFORM GLM_PLATFORM_QNXNTO
#elif defined(__APPLE__)
# define GLM_PLATFORM GLM_PLATFORM_APPLE
#elif defined(WINCE)
# define GLM_PLATFORM GLM_PLATFORM_WINCE
#elif defined(_WIN32)
# define GLM_PLATFORM GLM_PLATFORM_WINDOWS
#elif defined(__native_client__)
# define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
#elif defined(__ANDROID__)
# define GLM_PLATFORM GLM_PLATFORM_ANDROID
#elif defined(__linux)
# define GLM_PLATFORM GLM_PLATFORM_LINUX
#elif defined(__unix)
# define GLM_PLATFORM GLM_PLATFORM_UNIX
#else
# define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
#endif//
///////////////////////////////////////////////////////////////////////////////////
// Compiler
#define GLM_COMPILER_UNKNOWN 0x00000000
// Intel
#define GLM_COMPILER_INTEL 0x00100000
#define GLM_COMPILER_INTEL14 0x00100040
#define GLM_COMPILER_INTEL15 0x00100050
#define GLM_COMPILER_INTEL16 0x00100060
#define GLM_COMPILER_INTEL17 0x00100070
// Visual C++ defines
#define GLM_COMPILER_VC 0x01000000
#define GLM_COMPILER_VC12 0x01000001
#define GLM_COMPILER_VC14 0x01000002
#define GLM_COMPILER_VC15 0x01000003
#define GLM_COMPILER_VC15_3 0x01000004
#define GLM_COMPILER_VC15_5 0x01000005
#define GLM_COMPILER_VC15_6 0x01000006
#define GLM_COMPILER_VC15_7 0x01000007
// GCC defines
#define GLM_COMPILER_GCC 0x02000000
#define GLM_COMPILER_GCC46 0x020000D0
#define GLM_COMPILER_GCC47 0x020000E0
#define GLM_COMPILER_GCC48 0x020000F0
#define GLM_COMPILER_GCC49 0x02000100
#define GLM_COMPILER_GCC5 0x02000200
#define GLM_COMPILER_GCC6 0x02000300
#define GLM_COMPILER_GCC7 0x02000400
#define GLM_COMPILER_GCC8 0x02000500
// CUDA
#define GLM_COMPILER_CUDA 0x10000000
#define GLM_COMPILER_CUDA70 0x100000A0
#define GLM_COMPILER_CUDA75 0x100000B0
#define GLM_COMPILER_CUDA80 0x100000C0
// Clang
#define GLM_COMPILER_CLANG 0x20000000
#define GLM_COMPILER_CLANG34 0x20000050
#define GLM_COMPILER_CLANG35 0x20000060
#define GLM_COMPILER_CLANG36 0x20000070
#define GLM_COMPILER_CLANG37 0x20000080
#define GLM_COMPILER_CLANG38 0x20000090
#define GLM_COMPILER_CLANG39 0x200000A0
#define GLM_COMPILER_CLANG40 0x200000B0
#define GLM_COMPILER_CLANG41 0x200000C0
#define GLM_COMPILER_CLANG42 0x200000D0
// Build model
#define GLM_MODEL_32 0x00000010
#define GLM_MODEL_64 0x00000020
// Force generic C++ compiler
#ifdef GLM_FORCE_COMPILER_UNKNOWN
# define GLM_COMPILER GLM_COMPILER_UNKNOWN
#elif defined(__INTEL_COMPILER)
# if (__INTEL_COMPILER < 1400)
# error "GLM requires ICC 2013 SP1 or newer"
# elif __INTEL_COMPILER == 1400
# define GLM_COMPILER GLM_COMPILER_INTEL14
# elif __INTEL_COMPILER == 1500
# define GLM_COMPILER GLM_COMPILER_INTEL15
# elif __INTEL_COMPILER == 1600
# define GLM_COMPILER GLM_COMPILER_INTEL16
# elif __INTEL_COMPILER >= 1700
# define GLM_COMPILER GLM_COMPILER_INTEL17
# endif
// CUDA
#elif defined(__CUDACC__)
# if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA)
# include <cuda.h> // make sure version is defined since nvcc does not define it itself!
# endif
# if CUDA_VERSION < 7000
# error "GLM requires CUDA 7.0 or higher"
# elif (CUDA_VERSION >= 7000 && CUDA_VERSION < 7500)
# define GLM_COMPILER GLM_COMPILER_CUDA70
# elif (CUDA_VERSION >= 7500 && CUDA_VERSION < 8000)
# define GLM_COMPILER GLM_COMPILER_CUDA75
# elif (CUDA_VERSION >= 8000)
# define GLM_COMPILER GLM_COMPILER_CUDA80
# endif
// Clang
#elif defined(__clang__)
# if defined(__apple_build_version__)
# if (__clang_major__ < 6)
# error "GLM requires Clang 3.4 / Apple Clang 6.0 or higher"
# elif __clang_major__ == 6 && __clang_minor__ == 0
# define GLM_COMPILER GLM_COMPILER_CLANG35
# elif __clang_major__ == 6 && __clang_minor__ >= 1
# define GLM_COMPILER GLM_COMPILER_CLANG36
# elif __clang_major__ >= 7
# define GLM_COMPILER GLM_COMPILER_CLANG37
# endif
# else
# if ((__clang_major__ == 3) && (__clang_minor__ < 4)) || (__clang_major__ < 3)
# error "GLM requires Clang 3.4 or higher"
# elif __clang_major__ == 3 && __clang_minor__ == 4
# define GLM_COMPILER GLM_COMPILER_CLANG34
# elif __clang_major__ == 3 && __clang_minor__ == 5
# define GLM_COMPILER GLM_COMPILER_CLANG35
# elif __clang_major__ == 3 && __clang_minor__ == 6
# define GLM_COMPILER GLM_COMPILER_CLANG36
# elif __clang_major__ == 3 && __clang_minor__ == 7
# define GLM_COMPILER GLM_COMPILER_CLANG37
# elif __clang_major__ == 3 && __clang_minor__ == 8
# define GLM_COMPILER GLM_COMPILER_CLANG38
# elif __clang_major__ == 3 && __clang_minor__ >= 9
# define GLM_COMPILER GLM_COMPILER_CLANG39
# elif __clang_major__ == 4 && __clang_minor__ == 0
# define GLM_COMPILER GLM_COMPILER_CLANG40
# elif __clang_major__ == 4 && __clang_minor__ == 1
# define GLM_COMPILER GLM_COMPILER_CLANG41
# elif __clang_major__ == 4 && __clang_minor__ >= 2
# define GLM_COMPILER GLM_COMPILER_CLANG42
# elif __clang_major__ >= 4
# define GLM_COMPILER GLM_COMPILER_CLANG42
# endif
# endif
// Visual C++
#elif defined(_MSC_VER)
# if _MSC_VER < 1800
# error "GLM requires Visual C++ 12 - 2013 or higher"
# elif _MSC_VER == 1800
# define GLM_COMPILER GLM_COMPILER_VC12
# elif _MSC_VER == 1900
# define GLM_COMPILER GLM_COMPILER_VC14
# elif _MSC_VER == 1910
# define GLM_COMPILER GLM_COMPILER_VC15
# elif _MSC_VER == 1911
# define GLM_COMPILER GLM_COMPILER_VC15_3
# elif _MSC_VER == 1912
# define GLM_COMPILER GLM_COMPILER_VC15_5
# elif _MSC_VER == 1913
# define GLM_COMPILER GLM_COMPILER_VC15_6
# elif _MSC_VER >= 1914
# define GLM_COMPILER GLM_COMPILER_VC15_7
# endif//_MSC_VER
// G++
#elif defined(__GNUC__) || defined(__MINGW32__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ < 6)) || (__GNUC__ < 4)
# error "GLM requires GCC 4.7 or higher"
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
# define GLM_COMPILER (GLM_COMPILER_GCC46)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
# define GLM_COMPILER (GLM_COMPILER_GCC47)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
# define GLM_COMPILER (GLM_COMPILER_GCC48)
# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
# define GLM_COMPILER (GLM_COMPILER_GCC49)
# elif (__GNUC__ == 5)
# define GLM_COMPILER (GLM_COMPILER_GCC5)
# elif (__GNUC__ == 6)
# define GLM_COMPILER (GLM_COMPILER_GCC6)
# elif (__GNUC__ == 7)
# define GLM_COMPILER (GLM_COMPILER_GCC7)
# elif (__GNUC__ >= 8)
# define GLM_COMPILER (GLM_COMPILER_GCC8)
# endif
#else
# define GLM_COMPILER GLM_COMPILER_UNKNOWN
#endif
#ifndef GLM_COMPILER
# error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
#endif//GLM_COMPILER
///////////////////////////////////////////////////////////////////////////////////
// Instruction sets
// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2 GLM_FORCE_AVX2
#define GLM_ARCH_MIPS_BIT (0x10000000)
#define GLM_ARCH_PPC_BIT (0x20000000)
#define GLM_ARCH_ARM_BIT (0x40000000)
#define GLM_ARCH_X86_BIT (0x80000000)
#define GLM_ARCH_SIMD_BIT (0x00001000)
#define GLM_ARCH_NEON_BIT (0x00000001)
#define GLM_ARCH_SSE_BIT (0x00000002)
#define GLM_ARCH_SSE2_BIT (0x00000004)
#define GLM_ARCH_SSE3_BIT (0x00000008)
#define GLM_ARCH_SSSE3_BIT (0x00000010)
#define GLM_ARCH_SSE41_BIT (0x00000020)
#define GLM_ARCH_SSE42_BIT (0x00000040)
#define GLM_ARCH_AVX_BIT (0x00000080)
#define GLM_ARCH_AVX2_BIT (0x00000100)
#define GLM_ARCH_UNKNOWN (0)
#define GLM_ARCH_X86 (GLM_ARCH_X86_BIT)
#define GLM_ARCH_SSE (GLM_ARCH_SSE_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_X86)
#define GLM_ARCH_SSE2 (GLM_ARCH_SSE2_BIT | GLM_ARCH_SSE)
#define GLM_ARCH_SSE3 (GLM_ARCH_SSE3_BIT | GLM_ARCH_SSE2)
#define GLM_ARCH_SSSE3 (GLM_ARCH_SSSE3_BIT | GLM_ARCH_SSE3)
#define GLM_ARCH_SSE41 (GLM_ARCH_SSE41_BIT | GLM_ARCH_SSSE3)
#define GLM_ARCH_SSE42 (GLM_ARCH_SSE42_BIT | GLM_ARCH_SSE41)
#define GLM_ARCH_AVX (GLM_ARCH_AVX_BIT | GLM_ARCH_SSE42)
#define GLM_ARCH_AVX2 (GLM_ARCH_AVX2_BIT | GLM_ARCH_AVX)
#define GLM_ARCH_ARM (GLM_ARCH_ARM_BIT)
#define GLM_ARCH_NEON (GLM_ARCH_NEON_BIT | GLM_ARCH_SIMD_BIT | GLM_ARCH_ARM)
#define GLM_ARCH_MIPS (GLM_ARCH_MIPS_BIT)
#define GLM_ARCH_PPC (GLM_ARCH_PPC_BIT)
#ifdef GLM_FORCE_ARCH_UNKNOWN
# define GLM_ARCH GLM_ARCH_UNKNOWN
#elif defined(GLM_FORCE_PURE) || defined(GLM_FORCE_XYZW_ONLY)
# if defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86) || defined(__i386__)
# define GLM_ARCH (GLM_ARCH_X86)
# elif defined(__arm__ ) || defined(_M_ARM)
# define GLM_ARCH (GLM_ARCH_ARM)
# elif defined(__powerpc__ ) || defined(_M_PPC)
# define GLM_ARCH (GLM_ARCH_PPC)
# elif defined(__mips__ )
# define GLM_ARCH (GLM_ARCH_MIPS)
# else
# define GLM_ARCH (GLM_ARCH_UNKNOWN)
# endif
#elif defined(GLM_FORCE_NEON)
# define GLM_ARCH (GLM_ARCH_NEON)
#elif defined(GLM_FORCE_AVX2)
# define GLM_ARCH (GLM_ARCH_AVX2)
#elif defined(GLM_FORCE_AVX)
# define GLM_ARCH (GLM_ARCH_AVX)
#elif defined(GLM_FORCE_SSE42)
# define GLM_ARCH (GLM_ARCH_SSE42)
#elif defined(GLM_FORCE_SSE41)
# define GLM_ARCH (GLM_ARCH_SSE41)
#elif defined(GLM_FORCE_SSSE3)
# define GLM_ARCH (GLM_ARCH_SSSE3)
#elif defined(GLM_FORCE_SSE3)
# define GLM_ARCH (GLM_ARCH_SSE3)
#elif defined(GLM_FORCE_SSE2)
# define GLM_ARCH (GLM_ARCH_SSE2)
#elif defined(GLM_FORCE_SSE)
# define GLM_ARCH (GLM_ARCH_SSE)
#else
# if defined(__AVX2__)
# define GLM_ARCH (GLM_ARCH_AVX2)
# elif defined(__AVX__)
# define GLM_ARCH (GLM_ARCH_AVX)
# elif defined(__SSE4_2__)
# define GLM_ARCH (GLM_ARCH_SSE42)
# elif defined(__SSE4_1__)
# define GLM_ARCH (GLM_ARCH_SSE41)
# elif defined(__SSSE3__)
# define GLM_ARCH (GLM_ARCH_SSSE3)
# elif defined(__SSE3__)
# define GLM_ARCH (GLM_ARCH_SSE3)
# elif defined(__SSE2__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86_FP)
# define GLM_ARCH (GLM_ARCH_SSE2)
# elif defined(__i386__)
# define GLM_ARCH (GLM_ARCH_X86)
# elif defined(__ARM_NEON)
# define GLM_ARCH (GLM_ARCH_ARM | GLM_ARCH_NEON)
# elif defined(__arm__ ) || defined(_M_ARM)
# define GLM_ARCH (GLM_ARCH_ARM)
# elif defined(__mips__ )
# define GLM_ARCH (GLM_ARCH_MIPS)
# elif defined(__powerpc__ ) || defined(_M_PPC)
# define GLM_ARCH (GLM_ARCH_PPC)
# else
# define GLM_ARCH (GLM_ARCH_UNKNOWN)
# endif
#endif
#if GLM_ARCH & GLM_ARCH_AVX2_BIT
# include <immintrin.h>
#elif GLM_ARCH & GLM_ARCH_AVX_BIT
# include <immintrin.h>
#elif GLM_ARCH & GLM_ARCH_SSE42_BIT
# if GLM_COMPILER & GLM_COMPILER_CLANG
# include <popcntintrin.h>
# endif
# include <nmmintrin.h>
#elif GLM_ARCH & GLM_ARCH_SSE41_BIT
# include <smmintrin.h>
#elif GLM_ARCH & GLM_ARCH_SSSE3_BIT
# include <tmmintrin.h>
#elif GLM_ARCH & GLM_ARCH_SSE3_BIT
# include <pmmintrin.h>
#elif GLM_ARCH & GLM_ARCH_SSE2_BIT
# include <emmintrin.h>
#endif//GLM_ARCH
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
typedef __m128 glm_f32vec4;
typedef __m128i glm_i32vec4;
typedef __m128i glm_u32vec4;
typedef __m128d glm_f64vec2;
typedef __m128i glm_i64vec2;
typedef __m128i glm_u64vec2;
typedef glm_f32vec4 glm_vec4;
typedef glm_i32vec4 glm_ivec4;
typedef glm_u32vec4 glm_uvec4;
typedef glm_f64vec2 glm_dvec2;
#endif
#if GLM_ARCH & GLM_ARCH_AVX_BIT
typedef __m256d glm_f64vec4;
typedef glm_f64vec4 glm_dvec4;
#endif
#if GLM_ARCH & GLM_ARCH_AVX2_BIT
typedef __m256i glm_i64vec4;
typedef __m256i glm_u64vec4;
#endif
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/integer.h | .h | 3,803 | 116 | /// @ref simd
/// @file glm/simd/integer.h
#pragma once
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave(glm_uvec4 x)
{
glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF);
glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF);
glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333);
glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555);
glm_uvec4 Reg1;
glm_uvec4 Reg2;
// REG1 = x;
// REG2 = y;
//Reg1 = _mm_unpacklo_epi64(x, y);
Reg1 = x;
//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
Reg2 = _mm_slli_si128(Reg1, 2);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask4);
//REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
//REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
Reg2 = _mm_slli_si128(Reg1, 1);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask3);
//REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
//REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
Reg2 = _mm_slli_epi32(Reg1, 4);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask2);
//REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333);
//REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333);
Reg2 = _mm_slli_epi32(Reg1, 2);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask1);
//REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555);
//REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555);
Reg2 = _mm_slli_epi32(Reg1, 1);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask0);
//return REG1 | (REG2 << 1);
Reg2 = _mm_slli_epi32(Reg1, 1);
Reg2 = _mm_srli_si128(Reg2, 8);
Reg1 = _mm_or_si128(Reg1, Reg2);
return Reg1;
}
GLM_FUNC_QUALIFIER glm_uvec4 glm_i128_interleave2(glm_uvec4 x, glm_uvec4 y)
{
glm_uvec4 const Mask4 = _mm_set1_epi32(0x0000FFFF);
glm_uvec4 const Mask3 = _mm_set1_epi32(0x00FF00FF);
glm_uvec4 const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
glm_uvec4 const Mask1 = _mm_set1_epi32(0x33333333);
glm_uvec4 const Mask0 = _mm_set1_epi32(0x55555555);
glm_uvec4 Reg1;
glm_uvec4 Reg2;
// REG1 = x;
// REG2 = y;
Reg1 = _mm_unpacklo_epi64(x, y);
//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
Reg2 = _mm_slli_si128(Reg1, 2);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask4);
//REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
//REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
Reg2 = _mm_slli_si128(Reg1, 1);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask3);
//REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
//REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
Reg2 = _mm_slli_epi32(Reg1, 4);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask2);
//REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333);
//REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333);
Reg2 = _mm_slli_epi32(Reg1, 2);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask1);
//REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555);
//REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555);
Reg2 = _mm_slli_epi32(Reg1, 1);
Reg1 = _mm_or_si128(Reg2, Reg1);
Reg1 = _mm_and_si128(Reg1, Mask0);
//return REG1 | (REG2 << 1);
Reg2 = _mm_slli_epi32(Reg1, 1);
Reg2 = _mm_srli_si128(Reg2, 8);
Reg1 = _mm_or_si128(Reg1, Reg2);
return Reg1;
}
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/vector_relational.h | .h | 147 | 9 | /// @ref simd
/// @file glm/simd/vector_relational.h
#pragma once
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/common.h | .h | 7,243 | 241 | /// @ref simd
/// @file glm/simd/common.h
#pragma once
#include "platform.h"
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_add(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_add_ps(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_add(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_add_ss(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sub(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_sub_ps(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sub(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_sub_ss(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_mul(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_mul_ps(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_mul(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_mul_ss(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_div_ps(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_div(glm_f32vec4 a, glm_f32vec4 b)
{
return _mm_div_ss(a, b);
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_div_lowp(glm_f32vec4 a, glm_f32vec4 b)
{
return glm_vec4_mul(a, _mm_rcp_ps(b));
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_swizzle_xyzw(glm_f32vec4 a)
{
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
return _mm_permute_ps(a, _MM_SHUFFLE(3, 2, 1, 0));
# else
return _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 2, 1, 0));
# endif
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c)
{
# if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG)
return _mm_fmadd_ss(a, b, c);
# else
return _mm_add_ss(_mm_mul_ss(a, b), c);
# endif
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_fma(glm_f32vec4 a, glm_f32vec4 b, glm_f32vec4 c)
{
# if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG)
return _mm_fmadd_ps(a, b, c);
# else
return glm_vec4_add(glm_vec4_mul(a, b), c);
# endif
}
GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_abs(glm_f32vec4 x)
{
return _mm_and_ps(x, _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF)));
}
GLM_FUNC_QUALIFIER glm_ivec4 glm_ivec4_abs(glm_ivec4 x)
{
# if GLM_ARCH & GLM_ARCH_SSSE3_BIT
return _mm_sign_epi32(x, x);
# else
glm_ivec4 const sgn0 = _mm_srai_epi32(x, 31);
glm_ivec4 const inv0 = _mm_xor_si128(x, sgn0);
glm_ivec4 const sub0 = _mm_sub_epi32(inv0, sgn0);
return sub0;
# endif
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sign(glm_vec4 x)
{
glm_vec4 const zro0 = _mm_setzero_ps();
glm_vec4 const cmp0 = _mm_cmplt_ps(x, zro0);
glm_vec4 const cmp1 = _mm_cmpgt_ps(x, zro0);
glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(-1.0f));
glm_vec4 const and1 = _mm_and_ps(cmp1, _mm_set1_ps(1.0f));
glm_vec4 const or0 = _mm_or_ps(and0, and1);;
return or0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_round(glm_vec4 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_round_ps(x, _MM_FROUND_TO_NEAREST_INT);
# else
glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000)));
glm_vec4 const and0 = _mm_and_ps(sgn0, x);
glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f));
glm_vec4 const add0 = glm_vec4_add(x, or0);
glm_vec4 const sub0 = glm_vec4_sub(add0, or0);
return sub0;
# endif
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_floor(glm_vec4 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_floor_ps(x);
# else
glm_vec4 const rnd0 = glm_vec4_round(x);
glm_vec4 const cmp0 = _mm_cmplt_ps(x, rnd0);
glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
glm_vec4 const sub0 = glm_vec4_sub(rnd0, and0);
return sub0;
# endif
}
/* trunc TODO
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_trunc(glm_vec4 x)
{
return glm_vec4();
}
*/
//roundEven
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_roundEven(glm_vec4 x)
{
glm_vec4 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(int(0x80000000)));
glm_vec4 const and0 = _mm_and_ps(sgn0, x);
glm_vec4 const or0 = _mm_or_ps(and0, _mm_set_ps1(8388608.0f));
glm_vec4 const add0 = glm_vec4_add(x, or0);
glm_vec4 const sub0 = glm_vec4_sub(add0, or0);
return sub0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_ceil(glm_vec4 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_ceil_ps(x);
# else
glm_vec4 const rnd0 = glm_vec4_round(x);
glm_vec4 const cmp0 = _mm_cmpgt_ps(x, rnd0);
glm_vec4 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
glm_vec4 const add0 = glm_vec4_add(rnd0, and0);
return add0;
# endif
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_fract(glm_vec4 x)
{
glm_vec4 const flr0 = glm_vec4_floor(x);
glm_vec4 const sub0 = glm_vec4_sub(x, flr0);
return sub0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mod(glm_vec4 x, glm_vec4 y)
{
glm_vec4 const div0 = glm_vec4_div(x, y);
glm_vec4 const flr0 = glm_vec4_floor(div0);
glm_vec4 const mul0 = glm_vec4_mul(y, flr0);
glm_vec4 const sub0 = glm_vec4_sub(x, mul0);
return sub0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_clamp(glm_vec4 v, glm_vec4 minVal, glm_vec4 maxVal)
{
glm_vec4 const min0 = _mm_min_ps(v, maxVal);
glm_vec4 const max0 = _mm_max_ps(min0, minVal);
return max0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_mix(glm_vec4 v1, glm_vec4 v2, glm_vec4 a)
{
glm_vec4 const sub0 = glm_vec4_sub(_mm_set1_ps(1.0f), a);
glm_vec4 const mul0 = glm_vec4_mul(v1, sub0);
glm_vec4 const mad0 = glm_vec4_fma(v2, a, mul0);
return mad0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_step(glm_vec4 edge, glm_vec4 x)
{
glm_vec4 const cmp = _mm_cmple_ps(x, edge);
return _mm_movemask_ps(cmp) == 0 ? _mm_set1_ps(1.0f) : _mm_setzero_ps();
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_smoothstep(glm_vec4 edge0, glm_vec4 edge1, glm_vec4 x)
{
glm_vec4 const sub0 = glm_vec4_sub(x, edge0);
glm_vec4 const sub1 = glm_vec4_sub(edge1, edge0);
glm_vec4 const div0 = glm_vec4_sub(sub0, sub1);
glm_vec4 const clp0 = glm_vec4_clamp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f));
glm_vec4 const mul0 = glm_vec4_mul(_mm_set1_ps(2.0f), clp0);
glm_vec4 const sub2 = glm_vec4_sub(_mm_set1_ps(3.0f), mul0);
glm_vec4 const mul1 = glm_vec4_mul(clp0, clp0);
glm_vec4 const mul2 = glm_vec4_mul(mul1, sub2);
return mul2;
}
// Agner Fog method
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_nan(glm_vec4 x)
{
glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer
glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit
glm_ivec4 const t3 = _mm_set1_epi32(int(0xFF000000)); // exponent mask
glm_ivec4 const t4 = _mm_and_si128(t2, t3); // exponent
glm_ivec4 const t5 = _mm_andnot_si128(t3, t2); // fraction
glm_ivec4 const Equal = _mm_cmpeq_epi32(t3, t4);
glm_ivec4 const Nequal = _mm_cmpeq_epi32(t5, _mm_setzero_si128());
glm_ivec4 const And = _mm_and_si128(Equal, Nequal);
return _mm_castsi128_ps(And); // exponent = all 1s and fraction != 0
}
// Agner Fog method
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_inf(glm_vec4 x)
{
glm_ivec4 const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer
glm_ivec4 const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit
return _mm_castsi128_ps(_mm_cmpeq_epi32(t2, _mm_set1_epi32(int(0xFF000000)))); // exponent is all 1s, fraction is 0
}
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/geometric.h | .h | 4,046 | 125 | /// @ref simd
/// @file glm/simd/geometric.h
#pragma once
#include "common.h"
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_DECL glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2);
GLM_FUNC_DECL glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2);
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_length(glm_vec4 x)
{
glm_vec4 const dot0 = glm_vec4_dot(x, x);
glm_vec4 const sqt0 = _mm_sqrt_ps(dot0);
return sqt0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_distance(glm_vec4 p0, glm_vec4 p1)
{
glm_vec4 const sub0 = _mm_sub_ps(p0, p1);
glm_vec4 const len0 = glm_vec4_length(sub0);
return len0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_dot(glm_vec4 v1, glm_vec4 v2)
{
# if GLM_ARCH & GLM_ARCH_AVX_BIT
return _mm_dp_ps(v1, v2, 0xff);
# elif GLM_ARCH & GLM_ARCH_SSE3_BIT
glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
glm_vec4 const hadd0 = _mm_hadd_ps(mul0, mul0);
glm_vec4 const hadd1 = _mm_hadd_ps(hadd0, hadd0);
return hadd1;
# else
glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
glm_vec4 const swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
glm_vec4 const add0 = _mm_add_ps(mul0, swp0);
glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
glm_vec4 const add1 = _mm_add_ps(add0, swp1);
return add1;
# endif
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec1_dot(glm_vec4 v1, glm_vec4 v2)
{
# if GLM_ARCH & GLM_ARCH_AVX_BIT
return _mm_dp_ps(v1, v2, 0xff);
# elif GLM_ARCH & GLM_ARCH_SSE3_BIT
glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
glm_vec4 const had0 = _mm_hadd_ps(mul0, mul0);
glm_vec4 const had1 = _mm_hadd_ps(had0, had0);
return had1;
# else
glm_vec4 const mul0 = _mm_mul_ps(v1, v2);
glm_vec4 const mov0 = _mm_movehl_ps(mul0, mul0);
glm_vec4 const add0 = _mm_add_ps(mov0, mul0);
glm_vec4 const swp1 = _mm_shuffle_ps(add0, add0, 1);
glm_vec4 const add1 = _mm_add_ss(add0, swp1);
return add1;
# endif
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_cross(glm_vec4 v1, glm_vec4 v2)
{
glm_vec4 const swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
glm_vec4 const swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
glm_vec4 const swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
glm_vec4 const swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
glm_vec4 const mul0 = _mm_mul_ps(swp0, swp3);
glm_vec4 const mul1 = _mm_mul_ps(swp1, swp2);
glm_vec4 const sub0 = _mm_sub_ps(mul0, mul1);
return sub0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_normalize(glm_vec4 v)
{
glm_vec4 const dot0 = glm_vec4_dot(v, v);
glm_vec4 const isr0 = _mm_rsqrt_ps(dot0);
glm_vec4 const mul0 = _mm_mul_ps(v, isr0);
return mul0;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_faceforward(glm_vec4 N, glm_vec4 I, glm_vec4 Nref)
{
glm_vec4 const dot0 = glm_vec4_dot(Nref, I);
glm_vec4 const sgn0 = glm_vec4_sign(dot0);
glm_vec4 const mul0 = _mm_mul_ps(sgn0, _mm_set1_ps(-1.0f));
glm_vec4 const mul1 = _mm_mul_ps(N, mul0);
return mul1;
}
GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_reflect(glm_vec4 I, glm_vec4 N)
{
glm_vec4 const dot0 = glm_vec4_dot(N, I);
glm_vec4 const mul0 = _mm_mul_ps(N, dot0);
glm_vec4 const mul1 = _mm_mul_ps(mul0, _mm_set1_ps(2.0f));
glm_vec4 const sub0 = _mm_sub_ps(I, mul1);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(glm_vec4 I, glm_vec4 N, glm_vec4 eta)
{
glm_vec4 const dot0 = glm_vec4_dot(N, I);
glm_vec4 const mul0 = _mm_mul_ps(eta, eta);
glm_vec4 const mul1 = _mm_mul_ps(dot0, dot0);
glm_vec4 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), mul0);
glm_vec4 const sub1 = _mm_sub_ps(_mm_set1_ps(1.0f), mul1);
glm_vec4 const mul2 = _mm_mul_ps(sub0, sub1);
if(_mm_movemask_ps(_mm_cmplt_ss(mul2, _mm_set1_ps(0.0f))) == 0)
return _mm_set1_ps(0.0f);
glm_vec4 const sqt0 = _mm_sqrt_ps(mul2);
glm_vec4 const mad0 = glm_vec4_fma(eta, dot0, sqt0);
glm_vec4 const mul4 = _mm_mul_ps(mad0, N);
glm_vec4 const mul5 = _mm_mul_ps(eta, I);
glm_vec4 const sub2 = _mm_sub_ps(mul5, mul4);
return sub2;
}
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/packing.h | .h | 137 | 9 | /// @ref simd
/// @file glm/simd/packing.h
#pragma once
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/simd/trigonometric.h | .h | 145 | 10 | /// @ref simd
/// @file glm/simd/trigonometric.h
#pragma once
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_double.hpp | .hpp | 1,024 | 40 | /// @ref ext_quaternion_double
/// @file glm/ext/quaternion_double.hpp
///
/// @defgroup ext_quaternion_double GLM_EXT_quaternion_double
/// @ingroup ext
///
/// Exposes double-precision floating point quaternion type.
///
/// Include <glm/ext/quaternion_double.hpp> to use the features of this extension.
///
/// @see ext_quaternion_float
/// @see ext_quaternion_double_precision
/// @see ext_quaternion_common
/// @see ext_quaternion_exponential
/// @see ext_quaternion_geometric
/// @see ext_quaternion_relational
/// @see ext_quaternion_transform
/// @see ext_quaternion_trigonometric
#pragma once
// Dependency:
#include "../detail/type_quat.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_double extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_double
/// @{
/// Quaternion of double-precision floating-point numbers.
typedef qua<double, defaultp> dquat;
/// @}
} //namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x3_precision.hpp | .hpp | 1,613 | 32 | /// @ref core
/// @file glm/ext/matrix_float2x3_precision.hpp
#pragma once
#include "../detail/type_mat2x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, float, lowp> lowp_mat2x3;
/// 2 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, float, mediump> mediump_mat2x3;
/// 2 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, float, highp> highp_mat2x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_geometric.hpp | .hpp | 1,967 | 71 | /// @ref ext_quaternion_geometric
/// @file glm/ext/quaternion_geometric.hpp
///
/// @defgroup ext_quaternion_geometric GLM_EXT_quaternion_geometric
/// @ingroup ext
///
/// Provides geometric functions for quaternion types
///
/// Include <glm/ext/quaternion_geometric.hpp> to use the features of this extension.
///
/// @see core_geometric
/// @see ext_quaternion_float
/// @see ext_quaternion_double
#pragma once
// Dependency:
#include "../geometric.hpp"
#include "../exponential.hpp"
#include "../ext/vector_relational.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_geometric extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_geometric
/// @{
/// Returns the norm of a quaternions
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_geometric
template<typename T, qualifier Q>
GLM_FUNC_DECL T length(qua<T, Q> const& q);
/// Returns the normalized quaternion.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_geometric
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> normalize(qua<T, Q> const& q);
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
///
/// @tparam T Floating-point scalar types.
/// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_geometric
template<typename T, qualifier Q>
GLM_FUNC_DECL T dot(qua<T, Q> const& x, qua<T, Q> const& y);
/// Compute a cross product.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_geometric
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2);
/// @}
} //namespace glm
#include "quaternion_geometric.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double2_precision.hpp | .hpp | 1,431 | 32 | /// @ref core
/// @file glm/ext/vector_double2_precision.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 2 components vector of high double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, highp> highp_dvec2;
/// 2 components vector of medium double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, mediump> mediump_dvec2;
/// 2 components vector of low double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, lowp> lowp_dvec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float1.hpp | .hpp | 804 | 32 | /// @ref ext_vector_float1
/// @file glm/ext/vector_float1.hpp
///
/// @defgroup ext_vector_float1 GLM_EXT_vector_float1
/// @ingroup ext
///
/// Exposes single-precision floating point vector type with one component.
///
/// Include <glm/ext/vector_float1.hpp> to use the features of this extension.
///
/// @see ext_vector_float1_precision extension.
/// @see ext_vector_double1 extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_float1 extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_float1
/// @{
/// 1 components vector of single-precision floating-point numbers.
typedef vec<1, float, defaultp> vec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint3_precision.hpp | .hpp | 1,431 | 32 | /// @ref core
/// @file glm/ext/vector_uint3_precision.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 3 components vector of high qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, unsigned int, highp> highp_uvec3;
/// 3 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, unsigned int, mediump> mediump_uvec3;
/// 3 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, unsigned int, lowp> lowp_uvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool1_precision.hpp | .hpp | 910 | 35 | /// @ref ext_vector_bool1_precision
/// @file glm/ext/vector_bool1_precision.hpp
///
/// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision
/// @ingroup ext
///
/// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types.
///
/// Include <glm/ext/vector_bool1_precision.hpp> to use the features of this extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_bool1_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_bool1_precision
/// @{
/// 1 component vector of bool values.
typedef vec<1, bool, highp> highp_bvec1;
/// 1 component vector of bool values.
typedef vec<1, bool, mediump> mediump_bvec1;
/// 1 component vector of bool values.
typedef vec<1, bool, lowp> lowp_bvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_clip_space.hpp | .hpp | 30,247 | 523 | /// @ref ext_matrix_clip_space
/// @file glm/ext/matrix_clip_space.hpp
///
/// @defgroup ext_matrix_clip_space GLM_EXT_matrix_clip_space
/// @ingroup ext
///
/// Defines functions that generate clip space transformation matrices.
///
/// The matrices generated by this extension use standard OpenGL fixed-function
/// conventions. For example, the lookAt function generates a transform from world
/// space into the specific eye space that the projective matrix functions
/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
/// specifications defines the particular layout of this eye space.
///
/// Include <glm/ext/matrix_clip_space.hpp> to use the features of this extension.
///
/// @see ext_matrix_transform
/// @see ext_matrix_projection
#pragma once
// Dependencies
#include "../ext/scalar_constants.hpp"
#include "../geometric.hpp"
#include "../trigonometric.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_matrix_clip_space extension included")
#endif
namespace glm
{
/// @addtogroup ext_matrix_clip_space
/// @{
/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a>
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
T left, T right, T bottom, T top);
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition.
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @tparam T A floating-point scalar type
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml">glOrtho man page</a>
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
T left, T right, T bottom, T top, T zNear, T zFar);
/// Creates a left handed frustum matrix.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a left handed frustum matrix.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a right handed frustum matrix.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a right handed frustum matrix.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
T left, T right, T bottom, T top, T near, T far);
/// Creates a left handed frustum matrix.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
T left, T right, T bottom, T top, T near, T far);
/// Creates a right handed frustum matrix.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
T left, T right, T bottom, T top, T near, T far);
/// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition.
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @tparam T A floating-point scalar type
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml">glFrustum man page</a>
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum(
T left, T right, T bottom, T top, T near, T far);
/// Creates a matrix for a right handed, symetric perspective-view frustum.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a right handed, symetric perspective-view frustum.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a left handed, symetric perspective-view frustum.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a left handed, symetric perspective-view frustum.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a right handed, symetric perspective-view frustum.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a left handed, symetric perspective-view frustum.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
T fovy, T aspect, T near, T far);
/// Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition.
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @param fovy Specifies the field of view angle in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml">gluPerspective man page</a>
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
T fovy, T aspect, T near, T far);
/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
T fov, T width, T height, T near, T far);
/// Builds a right handed perspective projection matrix based on a field of view.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
T fov, T width, T height, T near, T far);
/// Builds a left handed perspective projection matrix based on a field of view.
/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
T fov, T width, T height, T near, T far);
/// Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition.
/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @param fov Expressed in radians.
/// @param width Width of the viewport
/// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
T fov, T width, T height, T near, T far);
/// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
T fovy, T aspect, T near);
/// Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite.
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near);
/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
///
/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param ep Epsilon
///
/// @tparam T A floating-point scalar type
template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near, T ep);
/// @}
}//namespace glm
#include "matrix_clip_space.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int2_precision.hpp | .hpp | 1,397 | 32 | /// @ref core
/// @file glm/ext/vector_int2_precision.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 2 components vector of high qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, highp> highp_ivec2;
/// 2 components vector of medium qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, mediump> mediump_ivec2;
/// 2 components vector of low qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, lowp> lowp_ivec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint4.hpp | .hpp | 435 | 19 | /// @ref core
/// @file glm/ext/vector_uint4.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 4 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, unsigned int, defaultp> uvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_ulp.hpp | .hpp | 2,130 | 75 | /// @ref ext_scalar_ulp
/// @file glm/ext/scalar_ulp.hpp
///
/// @defgroup ext_scalar_ulp GLM_EXT_scalar_ulp
/// @ingroup ext
///
/// Allow the measurement of the accuracy of a function against a reference
/// implementation. This extension works on floating-point data and provide results
/// in ULP.
///
/// Include <glm/ext/scalar_ulp.hpp> to use the features of this extension.
///
/// @see ext_vector_ulp
/// @see ext_scalar_relational
#pragma once
// Dependencies
#include "../ext/scalar_int_sized.hpp"
#include "../common.hpp"
#include "../detail/qualifier.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_ulp extension included")
#endif
namespace glm
{
/// Return the next ULP value(s) after the input value(s).
///
/// @tparam genType A floating-point scalar type.
///
/// @see ext_scalar_ulp
template<typename genType>
GLM_FUNC_DECL genType next_float(genType x);
/// Return the previous ULP value(s) before the input value(s).
///
/// @tparam genType A floating-point scalar type.
///
/// @see ext_scalar_ulp
template<typename genType>
GLM_FUNC_DECL genType prev_float(genType x);
/// Return the value(s) ULP distance after the input value(s).
///
/// @tparam genType A floating-point scalar type.
///
/// @see ext_scalar_ulp
template<typename genType>
GLM_FUNC_DECL genType next_float(genType x, int ULPs);
/// Return the value(s) ULP distance before the input value(s).
///
/// @tparam genType A floating-point scalar type.
///
/// @see ext_scalar_ulp
template<typename genType>
GLM_FUNC_DECL genType prev_float(genType x, int ULPs);
/// Return the distance in the number of ULP between 2 single-precision floating-point scalars.
///
/// @see ext_scalar_ulp
GLM_FUNC_DECL int float_distance(float x, float y);
/// Return the distance in the number of ULP between 2 double-precision floating-point scalars.
///
/// @see ext_scalar_ulp
GLM_FUNC_DECL int64 float_distance(double x, double y);
/// @}
}//namespace glm
#include "scalar_ulp.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float4.hpp | .hpp | 443 | 19 | /// @ref core
/// @file glm/ext/vector_float4.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 4 components vector of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, float, defaultp> vec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_relational.hpp | .hpp | 2,329 | 66 | /// @ref ext_scalar_relational
/// @file glm/ext/scalar_relational.hpp
///
/// @defgroup ext_scalar_relational GLM_EXT_scalar_relational
/// @ingroup ext
///
/// Exposes comparison functions for scalar types that take a user defined epsilon values.
///
/// Include <glm/ext/scalar_relational.hpp> to use the features of this extension.
///
/// @see core_vector_relational
/// @see ext_vector_relational
/// @see ext_matrix_relational
#pragma once
// Dependencies
#include "../detail/qualifier.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_relational extension included")
#endif
namespace glm
{
/// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is satisfied.
///
/// @tparam genType Floating-point or integer scalar types
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon);
/// Returns the component-wise comparison of |x - y| >= epsilon.
/// True if this expression is not satisfied.
///
/// @tparam genType Floating-point or integer scalar types
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon);
/// Returns the component-wise comparison between two scalars in term of ULPs.
/// True if this expression is satisfied.
///
/// @param x First operand.
/// @param y Second operand.
/// @param ULPs Maximum difference in ULPs between the two operators to consider them equal.
///
/// @tparam genType Floating-point or integer scalar types
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int ULPs);
/// Returns the component-wise comparison between two scalars in term of ULPs.
/// True if this expression is not satisfied.
///
/// @param x First operand.
/// @param y Second operand.
/// @param ULPs Maximum difference in ULPs between the two operators to consider them not equal.
///
/// @tparam genType Floating-point or integer scalar types
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs);
/// @}
}//namespace glm
#include "scalar_relational.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x3.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double2x3.hpp
#pragma once
#include "../detail/type_mat2x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 3 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 3, double, defaultp> dmat2x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double1_precision.hpp | .hpp | 1,191 | 37 | /// @ref ext_vector_double1_precision
/// @file glm/ext/vector_double1_precision.hpp
///
/// @defgroup ext_vector_double1_precision GLM_EXT_vector_double1_precision
/// @ingroup ext
///
/// Exposes highp_dvec1, mediump_dvec1 and lowp_dvec1 types.
///
/// Include <glm/ext/vector_double1_precision.hpp> to use the features of this extension.
///
/// @see ext_vector_double1
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_double1_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_double1_precision
/// @{
/// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
typedef vec<1, double, highp> highp_dvec1;
/// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
typedef vec<1, double, mediump> mediump_dvec1;
/// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
typedef vec<1, double, lowp> lowp_dvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint1.hpp | .hpp | 743 | 33 | /// @ref ext_vector_uint1
/// @file glm/ext/vector_uint1.hpp
///
/// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1
/// @ingroup ext
///
/// Exposes uvec1 vector type.
///
/// Include <glm/ext/vector_uvec1.hpp> to use the features of this extension.
///
/// @see ext_vector_int1 extension.
/// @see ext_vector_uint1_precision extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_uint1 extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_uint1
/// @{
/// 1 component vector of unsigned integer numbers.
typedef vec<1, unsigned int, defaultp> uvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x2_precision.hpp | .hpp | 3,004 | 50 | /// @ref core
/// @file glm/ext/matrix_float2x2_precision.hpp
#pragma once
#include "../detail/type_mat2x2.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, lowp> lowp_mat2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, mediump> mediump_mat2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, highp> highp_mat2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, lowp> lowp_mat2x2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, mediump> mediump_mat2x2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, highp> highp_mat2x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float4x3_precision.hpp | .hpp | 1,613 | 32 | /// @ref core
/// @file glm/ext/matrix_float4x3_precision.hpp
#pragma once
#include "../detail/type_mat4x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 4 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, float, lowp> lowp_mat4x3;
/// 4 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, float, mediump> mediump_mat4x3;
/// 4 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, float, highp> highp_mat4x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x4.hpp | .hpp | 466 | 19 | /// @ref core
/// @file glm/ext/matrix_float2x4.hpp
#pragma once
#include "../detail/type_mat2x4.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 4 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 4, float, defaultp> mat2x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int1_precision.hpp | .hpp | 930 | 35 | /// @ref ext_vector_int1_precision
/// @file glm/ext/vector_int1_precision.hpp
///
/// @defgroup ext_vector_int1_precision GLM_EXT_vector_int1_precision
/// @ingroup ext
///
/// Exposes highp_ivec1, mediump_ivec1 and lowp_ivec1 types.
///
/// Include <glm/ext/vector_int1_precision.hpp> to use the features of this extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_int1_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_int1_precision
/// @{
/// 1 component vector of signed integer values.
typedef vec<1, int, highp> highp_ivec1;
/// 1 component vector of signed integer values.
typedef vec<1, int, mediump> mediump_ivec1;
/// 1 component vector of signed integer values.
typedef vec<1, int, lowp> lowp_ivec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint2_precision.hpp | .hpp | 1,431 | 32 | /// @ref core
/// @file glm/ext/vector_uint2_precision.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 2 components vector of high qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, unsigned int, highp> highp_uvec2;
/// 2 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, unsigned int, mediump> mediump_uvec2;
/// 2 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, unsigned int, lowp> lowp_uvec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float2.hpp | .hpp | 442 | 19 | /// @ref core
/// @file glm/ext/vector_float2.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 2 components vector of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<2, float, defaultp> vec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double4.hpp | .hpp | 446 | 19 | /// @ref core
/// @file glm/ext/vector_double4.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 4 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, double, defaultp> dvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_relational.hpp | .hpp | 6,842 | 133 | /// @ref ext_matrix_relational
/// @file glm/ext/matrix_relational.hpp
///
/// @defgroup ext_matrix_relational GLM_EXT_matrix_relational
/// @ingroup ext
///
/// Exposes comparison functions for matrix types that take a user defined epsilon values.
///
/// Include <glm/ext/matrix_relational.hpp> to use the features of this extension.
///
/// @see ext_vector_relational
/// @see ext_scalar_relational
/// @see ext_quaternion_relational
#pragma once
// Dependencies
#include "../detail/qualifier.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_matrix_relational extension included")
#endif
namespace glm
{
/// @addtogroup ext_matrix_relational
/// @{
/// Perform a component-wise equal-to comparison of two matrices.
/// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y);
/// Perform a component-wise not-equal-to comparison of two matrices.
/// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y);
/// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, T epsilon);
/// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, T, Q> const& epsilon);
/// Returns the component-wise comparison of |x - y| < epsilon.
/// True if this expression is not satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, T epsilon);
/// Returns the component-wise comparison of |x - y| >= epsilon.
/// True if this expression is not satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, T, Q> const& epsilon);
/// Returns the component-wise comparison between two vectors in term of ULPs.
/// True if this expression is satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, int ULPs);
/// Returns the component-wise comparison between two vectors in term of ULPs.
/// True if this expression is satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> equal(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, int, Q> const& ULPs);
/// Returns the component-wise comparison between two vectors in term of ULPs.
/// True if this expression is not satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, int ULPs);
/// Returns the component-wise comparison between two vectors in term of ULPs.
/// True if this expression is not satisfied.
///
/// @tparam C Integer between 1 and 4 included that qualify the number of columns of the matrix
/// @tparam R Integer between 1 and 4 included that qualify the number of rows of the matrix
/// @tparam T Floating-point
/// @tparam Q Value from qualifier enum
template<length_t C, length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<C, bool, Q> notEqual(mat<C, R, T, Q> const& x, mat<C, R, T, Q> const& y, vec<C, int, Q> const& ULPs);
/// @}
}//namespace glm
#include "matrix_relational.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float4x3.hpp | .hpp | 467 | 19 | /// @ref core
/// @file glm/ext/matrix_float4x3.hpp
#pragma once
#include "../detail/type_mat4x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 4 columns of 3 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 3, float, defaultp> mat4x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float2_precision.hpp | .hpp | 1,425 | 32 | /// @ref core
/// @file glm/ext/vector_float2_precision.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 2 components vector of high single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, highp> highp_vec2;
/// 2 components vector of medium single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, mediump> mediump_vec2;
/// 2 components vector of low single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, lowp> lowp_vec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x4_precision.hpp | .hpp | 3,019 | 50 | /// @ref core
/// @file glm/ext/matrix_double4x4_precision.hpp
#pragma once
#include "../detail/type_mat4x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, lowp> lowp_dmat4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, mediump> mediump_dmat4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, highp> highp_dmat4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, lowp> lowp_dmat4x4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, mediump> mediump_dmat4x4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, highp> highp_dmat4x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_common.hpp | .hpp | 6,948 | 145 | /// @ref ext_vector_common
/// @file glm/ext/vector_common.hpp
///
/// @defgroup ext_vector_common GLM_EXT_vector_common
/// @ingroup ext
///
/// Exposes min and max functions for 3 to 4 vector parameters.
///
/// Include <glm/ext/vector_common.hpp> to use the features of this extension.
///
/// @see core_common
/// @see ext_scalar_common
#pragma once
// Dependency:
#include "../ext/scalar_common.hpp"
#include "../common.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_common extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_common
/// @{
/// Return the minimum component-wise values of 3 inputs
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
/// Return the minimum component-wise values of 4 inputs
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
/// Return the maximum component-wise values of 3 inputs
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z);
/// Return the maximum component-wise values of 4 inputs
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> max( vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& z, vec<L, T, Q> const& w);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, T y);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b, vec<L, T, Q> const& c, vec<L, T, Q> const& d);
/// @}
}//namespace glm
#include "vector_common.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double3x4_precision.hpp | .hpp | 1,621 | 32 | /// @ref core
/// @file glm/ext/matrix_double3x4_precision.hpp
#pragma once
#include "../detail/type_mat3x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 3 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, double, lowp> lowp_dmat3x4;
/// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, double, mediump> mediump_dmat3x4;
/// 3 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, double, highp> highp_dmat3x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float3x4_precision.hpp | .hpp | 1,613 | 32 | /// @ref core
/// @file glm/ext/matrix_float3x4_precision.hpp
#pragma once
#include "../detail/type_mat3x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 3 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, float, lowp> lowp_mat3x4;
/// 3 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, float, mediump> mediump_mat3x4;
/// 3 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, float, highp> highp_mat3x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint1_precision.hpp | .hpp | 1,102 | 41 | /// @ref ext_vector_uint1_precision
/// @file glm/ext/vector_uint1_precision.hpp
///
/// @defgroup ext_vector_uint1_precision GLM_EXT_vector_uint1_precision
/// @ingroup ext
///
/// Exposes highp_uvec1, mediump_uvec1 and lowp_uvec1 types.
///
/// Include <glm/ext/vector_uint1_precision.hpp> to use the features of this extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_uint1_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_uint1_precision
/// @{
/// 1 component vector of unsigned integer values.
///
/// @see ext_vector_uint1_precision
typedef vec<1, unsigned int, highp> highp_uvec1;
/// 1 component vector of unsigned integer values.
///
/// @see ext_vector_uint1_precision
typedef vec<1, unsigned int, mediump> mediump_uvec1;
/// 1 component vector of unsigned integer values.
///
/// @see ext_vector_uint1_precision
typedef vec<1, unsigned int, lowp> lowp_uvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int4_precision.hpp | .hpp | 1,397 | 32 | /// @ref core
/// @file glm/ext/vector_int4_precision.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 4 components vector of high qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, highp> highp_ivec4;
/// 4 components vector of medium qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, mediump> mediump_ivec4;
/// 4 components vector of low qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, lowp> lowp_ivec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x2_precision.hpp | .hpp | 1,621 | 32 | /// @ref core
/// @file glm/ext/matrix_double4x2_precision.hpp
#pragma once
#include "../detail/type_mat4x2.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 4 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, double, lowp> lowp_dmat4x2;
/// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, double, mediump> mediump_dmat4x2;
/// 4 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, double, highp> highp_dmat4x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x4.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double2x4.hpp
#pragma once
#include "../detail/type_mat2x4.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 4 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 4, double, defaultp> dmat2x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float4_precision.hpp | .hpp | 1,425 | 32 | /// @ref core
/// @file glm/ext/vector_float4_precision.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 4 components vector of high single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, highp> highp_vec4;
/// 4 components vector of medium single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, mediump> mediump_vec4;
/// 4 components vector of low single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, lowp> lowp_vec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float4x4_precision.hpp | .hpp | 3,004 | 50 | /// @ref core
/// @file glm/ext/matrix_float4x4_precision.hpp
#pragma once
#include "../detail/type_mat4x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, lowp> lowp_mat4;
/// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, mediump> mediump_mat4;
/// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, highp> highp_mat4;
/// 4 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, lowp> lowp_mat4x4;
/// 4 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, mediump> mediump_mat4x4;
/// 4 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, highp> highp_mat4x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x4_precision.hpp | .hpp | 1,613 | 32 | /// @ref core
/// @file glm/ext/matrix_float2x4_precision.hpp
#pragma once
#include "../detail/type_mat2x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 4 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, float, lowp> lowp_mat2x4;
/// 2 columns of 4 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, float, mediump> mediump_mat2x4;
/// 2 columns of 4 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, float, highp> highp_mat2x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool3.hpp | .hpp | 410 | 19 | /// @ref core
/// @file glm/ext/vector_bool3.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 3 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, bool, defaultp> bvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x2.hpp | .hpp | 739 | 24 | /// @ref core
/// @file glm/ext/matrix_double2x2.hpp
#pragma once
#include "../detail/type_mat2x2.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 2 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 2, double, defaultp> dmat2x2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 2, double, defaultp> dmat2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool1.hpp | .hpp | 679 | 31 | /// @ref ext_vector_bool1
/// @file glm/ext/vector_bool1.hpp
///
/// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1
/// @ingroup ext
///
/// Exposes bvec1 vector type.
///
/// Include <glm/ext/vector_bool1.hpp> to use the features of this extension.
///
/// @see ext_vector_bool1_precision extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_bool1 extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_bool1
/// @{
/// 1 components vector of boolean.
typedef vec<1, bool, defaultp> bvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_common.hpp | .hpp | 3,577 | 104 | /// @ref ext_scalar_common
/// @file glm/ext/scalar_common.hpp
///
/// @defgroup ext_scalar_common GLM_EXT_scalar_common
/// @ingroup ext
///
/// Exposes min and max functions for 3 to 4 scalar parameters.
///
/// Include <glm/ext/scalar_common.hpp> to use the features of this extension.
///
/// @see core_func_common
/// @see ext_vector_common
#pragma once
// Dependency:
#include "../common.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_common extension included")
#endif
namespace glm
{
/// @addtogroup ext_scalar_common
/// @{
/// Returns the minimum component-wise values of 3 inputs
///
/// @tparam T A floating-point scalar type.
template<typename T>
GLM_FUNC_DECL T min(T a, T b, T c);
/// Returns the minimum component-wise values of 4 inputs
///
/// @tparam T A floating-point scalar type.
template<typename T>
GLM_FUNC_DECL T min(T a, T b, T c, T d);
/// Returns the maximum component-wise values of 3 inputs
///
/// @tparam T A floating-point scalar type.
template<typename T>
GLM_FUNC_DECL T max(T a, T b, T c);
/// Returns the maximum component-wise values of 4 inputs
///
/// @tparam T A floating-point scalar type.
template<typename T>
GLM_FUNC_DECL T max(T a, T b, T c, T d);
/// Returns the minimum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<typename T>
GLM_FUNC_DECL T fmin(T a, T b);
/// Returns the minimum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<typename T>
GLM_FUNC_DECL T fmin(T a, T b, T c);
/// Returns the minimum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<typename T>
GLM_FUNC_DECL T fmin(T a, T b, T c, T d);
/// Returns the maximum component-wise values of 2 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<typename T>
GLM_FUNC_DECL T fmax(T a, T b);
/// Returns the maximum component-wise values of 3 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<typename T>
GLM_FUNC_DECL T fmax(T a, T b, T C);
/// Returns the maximum component-wise values of 4 inputs. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam T A floating-point scalar type.
///
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<typename T>
GLM_FUNC_DECL T fmax(T a, T b, T C, T D);
/// @}
}//namespace glm
#include "scalar_common.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float3x3.hpp | .hpp | 736 | 24 | /// @ref core
/// @file glm/ext/matrix_float3x3.hpp
#pragma once
#include "../detail/type_mat3x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 3 columns of 3 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 3, float, defaultp> mat3x3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 3, float, defaultp> mat3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x4_precision.hpp | .hpp | 1,621 | 32 | /// @ref core
/// @file glm/ext/matrix_double2x4_precision.hpp
#pragma once
#include "../detail/type_mat2x4.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 4 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, double, lowp> lowp_dmat2x4;
/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, double, mediump> mediump_dmat2x4;
/// 2 columns of 4 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, double, highp> highp_dmat2x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double3x4.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double3x4.hpp
#pragma once
#include "../detail/type_mat3x4.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 3 columns of 4 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 4, double, defaultp> dmat3x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float3x4.hpp | .hpp | 467 | 19 | /// @ref core
/// @file glm/ext/matrix_float3x4.hpp
#pragma once
#include "../detail/type_mat3x4.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 3 columns of 4 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 4, float, defaultp> mat3x4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x4.hpp | .hpp | 739 | 24 | /// @ref core
/// @file glm/ext/matrix_double4x4.hpp
#pragma once
#include "../detail/type_mat4x4.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 4 columns of 4 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 4, double, defaultp> dmat4x4;
/// 4 columns of 4 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 4, double, defaultp> dmat4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double3.hpp | .hpp | 446 | 19 | /// @ref core
/// @file glm/ext/vector_double3.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 3 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, double, defaultp> dvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float3x3_precision.hpp | .hpp | 3,004 | 50 | /// @ref core
/// @file glm/ext/matrix_float3x3_precision.hpp
#pragma once
#include "../detail/type_mat3x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, lowp> lowp_mat3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, mediump> mediump_mat3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, highp> highp_mat3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, lowp> lowp_mat3x3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, mediump> mediump_mat3x3;
/// 3 columns of 3 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, highp> highp_mat3x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double3_precision.hpp | .hpp | 1,590 | 35 | /// @ref core
/// @file glm/ext/vector_double3_precision.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 3 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, highp> highp_dvec3;
/// 3 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, mediump> mediump_dvec3;
/// 3 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, lowp> lowp_dvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_projection.hpp | .hpp | 8,205 | 150 | /// @ref ext_matrix_projection
/// @file glm/ext/matrix_projection.hpp
///
/// @defgroup ext_matrix_projection GLM_EXT_matrix_projection
/// @ingroup ext
///
/// Functions that generate common projection transformation matrices.
///
/// The matrices generated by this extension use standard OpenGL fixed-function
/// conventions. For example, the lookAt function generates a transform from world
/// space into the specific eye space that the projective matrix functions
/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
/// specifications defines the particular layout of this eye space.
///
/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension.
///
/// @see ext_matrix_transform
/// @see ext_matrix_clip_space
#pragma once
// Dependencies
#include "../gtc/constants.hpp"
#include "../geometric.hpp"
#include "../trigonometric.hpp"
#include "../matrix.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_matrix_projection extension included")
#endif
namespace glm
{
/// @addtogroup ext_matrix_projection
/// @{
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param obj Specify the object coordinates.
/// @param model Specifies the current modelview matrix
/// @param proj Specifies the current projection matrix
/// @param viewport Specifies the current viewport
/// @return Return the computed window coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> projectZO(
vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param obj Specify the object coordinates.
/// @param model Specifies the current modelview matrix
/// @param proj Specifies the current projection matrix
/// @param viewport Specifies the current viewport
/// @return Return the computed window coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> projectNO(
vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition.
/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @param obj Specify the object coordinates.
/// @param model Specifies the current modelview matrix
/// @param proj Specifies the current projection matrix
/// @param viewport Specifies the current viewport
/// @return Return the computed window coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> project(
vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
///
/// @param win Specify the window coordinates to be mapped.
/// @param model Specifies the modelview matrix
/// @param proj Specifies the projection matrix
/// @param viewport Specifies the viewport
/// @return Returns the computed object coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> unProjectZO(
vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
///
/// @param win Specify the window coordinates to be mapped.
/// @param model Specifies the modelview matrix
/// @param proj Specifies the projection matrix
/// @param viewport Specifies the viewport
/// @return Returns the computed object coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> unProjectNO(
vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition.
/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
///
/// @param win Specify the window coordinates to be mapped.
/// @param model Specifies the modelview matrix
/// @param proj Specifies the projection matrix
/// @param viewport Specifies the viewport
/// @return Returns the computed object coordinates.
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a>
template<typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> unProject(
vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
/// Define a picking region
///
/// @param center Specify the center of a picking region in window coordinates.
/// @param delta Specify the width and height, respectively, of the picking region in window coordinates.
/// @param viewport Rendering viewport
/// @tparam T Native type used for the computation. Currently supported: half (not recommended), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
///
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPickMatrix.xml">gluPickMatrix man page</a>
template<typename T, qualifier Q, typename U>
GLM_FUNC_DECL mat<4, 4, T, Q> pickMatrix(
vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport);
/// @}
}//namespace glm
#include "matrix_projection.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x2.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double4x2.hpp
#pragma once
#include "../detail/type_mat4x2.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 4 columns of 2 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 2, double, defaultp> dmat4x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float3.hpp | .hpp | 443 | 19 | /// @ref core
/// @file glm/ext/vector_float3.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 3 components vector of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, float, defaultp> vec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint3.hpp | .hpp | 435 | 19 | /// @ref core
/// @file glm/ext/vector_uint3.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 3 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, unsigned int, defaultp> uvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float4x2.hpp | .hpp | 467 | 19 | /// @ref core
/// @file glm/ext/matrix_float4x2.hpp
#pragma once
#include "../detail/type_mat4x2.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 4 columns of 2 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 2, float, defaultp> mat4x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int2.hpp | .hpp | 423 | 19 | /// @ref core
/// @file glm/ext/vector_int2.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 2 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<2, int, defaultp> ivec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_transform.hpp | .hpp | 1,378 | 48 | /// @ref ext_quaternion_transform
/// @file glm/ext/quaternion_transform.hpp
///
/// @defgroup ext_quaternion_transform GLM_EXT_quaternion_transform
/// @ingroup ext
///
/// Provides transformation functions for quaternion types
///
/// Include <glm/ext/quaternion_transform.hpp> to use the features of this extension.
///
/// @see ext_quaternion_float
/// @see ext_quaternion_double
/// @see ext_quaternion_exponential
/// @see ext_quaternion_geometric
/// @see ext_quaternion_relational
/// @see ext_quaternion_trigonometric
#pragma once
// Dependency:
#include "../common.hpp"
#include "../trigonometric.hpp"
#include "../geometric.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_transform extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_transform
/// @{
/// Rotates a quaternion from a vector of 3 components axis and an angle.
///
/// @param q Source orientation
/// @param angle Angle expressed in radians.
/// @param axis Axis of the rotation
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> rotate(qua<T, Q> const& q, T const& angle, vec<3, T, Q> const& axis);
/// @}
} //namespace glm
#include "quaternion_transform.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool3_precision.hpp | .hpp | 1,371 | 32 | /// @ref core
/// @file glm/ext/vector_bool3_precision.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 3 components vector of high qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, bool, highp> highp_bvec3;
/// 3 components vector of medium qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, bool, mediump> mediump_bvec3;
/// 3 components vector of low qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, bool, lowp> lowp_bvec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_uint4_precision.hpp | .hpp | 1,431 | 32 | /// @ref core
/// @file glm/ext/vector_uint4_precision.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 4 components vector of high qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, unsigned int, highp> highp_uvec4;
/// 4 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, unsigned int, mediump> mediump_uvec4;
/// 4 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, unsigned int, lowp> lowp_uvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool4.hpp | .hpp | 410 | 19 | /// @ref core
/// @file glm/ext/vector_bool4.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 4 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, bool, defaultp> bvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool4_precision.hpp | .hpp | 1,371 | 32 | /// @ref core
/// @file glm/ext/vector_bool4_precision.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 4 components vector of high qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, bool, highp> highp_bvec4;
/// 4 components vector of medium qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, bool, mediump> mediump_bvec4;
/// 4 components vector of low qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, bool, lowp> lowp_bvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double3x3.hpp | .hpp | 739 | 24 | /// @ref core
/// @file glm/ext/matrix_double3x3.hpp
#pragma once
#include "../detail/type_mat3x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 3 columns of 3 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 3, double, defaultp> dmat3x3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 3, double, defaultp> dmat3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int4.hpp | .hpp | 423 | 19 | /// @ref core
/// @file glm/ext/vector_int4.hpp
#pragma once
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 4 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, int, defaultp> ivec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_transform.hpp | .hpp | 6,170 | 145 | /// @ref ext_matrix_transform
/// @file glm/ext/matrix_transform.hpp
///
/// @defgroup ext_matrix_transform GLM_EXT_matrix_transform
/// @ingroup ext
///
/// Defines functions that generate common transformation matrices.
///
/// The matrices generated by this extension use standard OpenGL fixed-function
/// conventions. For example, the lookAt function generates a transform from world
/// space into the specific eye space that the projective matrix functions
/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
/// specifications defines the particular layout of this eye space.
///
/// Include <glm/ext/matrix_transform.hpp> to use the features of this extension.
///
/// @see ext_matrix_projection
/// @see ext_matrix_clip_space
#pragma once
// Dependencies
#include "../gtc/constants.hpp"
#include "../geometric.hpp"
#include "../trigonometric.hpp"
#include "../matrix.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_matrix_transform extension included")
#endif
namespace glm
{
/// @addtogroup ext_matrix_transform
/// @{
/// Builds an identity matrix.
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType identity();
/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a translation vector.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @code
/// #include <glm/glm.hpp>
/// #include <glm/gtc/matrix_transform.hpp>
/// ...
/// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
/// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
/// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
/// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
/// @endcode
///
/// @see - translate(mat<4, 4, T, Q> const& m, T x, T y, T z)
/// @see - translate(vec<3, T, Q> const& v)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml">glTranslate man page</a>
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> translate(
mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
///
/// @param m Input matrix multiplied by this rotation matrix.
/// @param angle Rotation angle expressed in radians.
/// @param axis Rotation axis, recommended to be normalized.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z)
/// @see - rotate(T angle, vec<3, T, Q> const& v)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml">glRotate man page</a>
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> rotate(
mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& axis);
/// Builds a scale 4 * 4 matrix created from 3 scalars.
///
/// @param m Input matrix multiplied by this scale matrix.
/// @param v Ratio of scaling for each axis.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @see - scale(mat<4, 4, T, Q> const& m, T x, T y, T z)
/// @see - scale(vec<3, T, Q> const& v)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glScale.xml">glScale man page</a>
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> scale(
mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
/// Build a right handed look at view matrix.
///
/// @param eye Position of the camera
/// @param center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH(
vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
/// Build a left handed look at view matrix.
///
/// @param eye Position of the camera
/// @param center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH(
vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
/// Build a look at view matrix based on the default handedness.
///
/// @param eye Position of the camera
/// @param center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
///
/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml">gluLookAt man page</a>
template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> lookAt(
vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
/// @}
}//namespace glm
#include "matrix_transform.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x2.hpp | .hpp | 734 | 24 | /// @ref core
/// @file glm/ext/matrix_float2x2.hpp
#pragma once
#include "../detail/type_mat2x2.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 2 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 2, float, defaultp> mat2x2;
/// 2 columns of 2 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 2, float, defaultp> mat2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float3x2_precision.hpp | .hpp | 1,613 | 32 | /// @ref core
/// @file glm/ext/matrix_float3x2_precision.hpp
#pragma once
#include "../detail/type_mat3x2.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 3 columns of 2 components matrix of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, float, lowp> lowp_mat3x2;
/// 3 columns of 2 components matrix of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, float, mediump> mediump_mat3x2;
/// 3 columns of 2 components matrix of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, float, highp> highp_mat3x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double2.hpp | .hpp | 446 | 19 | /// @ref core
/// @file glm/ext/vector_double2.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 2 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<2, double, defaultp> dvec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_relational.hpp | .hpp | 2,016 | 63 | /// @ref ext_quaternion_relational
/// @file glm/ext/quaternion_relational.hpp
///
/// @defgroup ext_quaternion_relational GLM_EXT_quaternion_relational
/// @ingroup ext
///
/// Exposes comparison functions for quaternion types that take a user defined epsilon values.
///
/// Include <glm/ext/quaternion_relational.hpp> to use the features of this extension.
///
/// @see core_vector_relational
/// @see ext_vector_relational
/// @see ext_matrix_relational
/// @see ext_quaternion_float
/// @see ext_quaternion_double
#pragma once
// Dependency:
#include "../vector_relational.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_relational extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_relational
/// @{
/// Returns the component-wise comparison of result x == y.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y);
/// Returns the component-wise comparison of |x - y| < epsilon.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
/// Returns the component-wise comparison of result x != y.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y);
/// Returns the component-wise comparison of |x - y| >= epsilon.
///
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
/// @}
} //namespace glm
#include "quaternion_relational.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x2_precision.hpp | .hpp | 3,019 | 50 | /// @ref core
/// @file glm/ext/matrix_double2x2_precision.hpp
#pragma once
#include "../detail/type_mat2x2.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, lowp> lowp_dmat2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, mediump> mediump_dmat2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, highp> highp_dmat2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, lowp> lowp_dmat2x2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, mediump> mediump_dmat2x2;
/// 2 columns of 2 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, highp> highp_dmat2x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x3.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double4x3.hpp
#pragma once
#include "../detail/type_mat4x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 4 columns of 3 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<4, 3, double, defaultp> dmat4x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double4_precision.hpp | .hpp | 1,622 | 36 | /// @ref core
/// @file glm/ext/vector_double4_precision.hpp
#pragma once
#include "../detail/setup.hpp"
#include "../detail/type_vec4.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 4 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, highp> highp_dvec4;
/// 4 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, mediump> mediump_dvec4;
/// 4 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, lowp> lowp_dvec4;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_float.hpp | .hpp | 1,015 | 40 | /// @ref ext_quaternion_float
/// @file glm/ext/quaternion_float.hpp
///
/// @defgroup ext_quaternion_float GLM_EXT_quaternion_float
/// @ingroup ext
///
/// Exposes single-precision floating point quaternion type.
///
/// Include <glm/ext/quaternion_float.hpp> to use the features of this extension.
///
/// @see ext_quaternion_double
/// @see ext_quaternion_float_precision
/// @see ext_quaternion_common
/// @see ext_quaternion_exponential
/// @see ext_quaternion_geometric
/// @see ext_quaternion_relational
/// @see ext_quaternion_transform
/// @see ext_quaternion_trigonometric
#pragma once
// Dependency:
#include "../detail/type_quat.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_float extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_float
/// @{
/// Quaternion of single-precision floating-point numbers.
typedef qua<float, defaultp> quat;
/// @}
} //namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_int_sized.hpp | .hpp | 1,383 | 71 | /// @ref ext_scalar_int_sized
/// @file glm/ext/scalar_int_sized.hpp
///
/// @defgroup ext_scalar_int_sized GLM_EXT_scalar_int_sized
/// @ingroup ext
///
/// Exposes sized signed integer scalar types.
///
/// Include <glm/ext/scalar_int_sized.hpp> to use the features of this extension.
///
/// @see ext_scalar_uint_sized
#pragma once
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_int_sized extension included")
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::int8_t int8;
typedef std::int16_t int16;
typedef std::int32_t int32;
# else
typedef char int8;
typedef short int16;
typedef int int32;
#endif//
template<>
struct is_int<int8>
{
enum test {value = ~0};
};
template<>
struct is_int<int16>
{
enum test {value = ~0};
};
template<>
struct is_int<int64>
{
enum test {value = ~0};
};
}//namespace detail
/// @addtogroup ext_scalar_int_sized
/// @{
/// 8 bit signed integer type.
typedef detail::int8 int8;
/// 16 bit signed integer type.
typedef detail::int16 int16;
/// 32 bit signed integer type.
typedef detail::int32 int32;
/// 64 bit signed integer type.
typedef detail::int64 int64;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int3_precision.hpp | .hpp | 1,397 | 32 | /// @ref core
/// @file glm/ext/vector_int3_precision.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector_precision
/// @{
/// 3 components vector of high qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, highp> highp_ivec3;
/// 3 components vector of medium qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, mediump> mediump_ivec3;
/// 3 components vector of low qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, lowp> lowp_ivec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_double_precision.hpp | .hpp | 1,360 | 43 | /// @ref ext_quaternion_double_precision
/// @file glm/ext/quaternion_double_precision.hpp
///
/// @defgroup ext_quaternion_double_precision GLM_EXT_quaternion_double_precision
/// @ingroup ext
///
/// Exposes double-precision floating point quaternion type with various precision in term of ULPs.
///
/// Include <glm/ext/quaternion_double_precision.hpp> to use the features of this extension.
#pragma once
// Dependency:
#include "../detail/type_quat.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_double_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_double_precision
/// @{
/// Quaternion of double-precision floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see ext_quaternion_double_precision
typedef qua<double, lowp> lowp_dquat;
/// Quaternion of medium double-qualifier floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see ext_quaternion_double_precision
typedef qua<double, mediump> mediump_dquat;
/// Quaternion of high double-qualifier floating-point numbers using high precision arithmetic in term of ULPs.
///
/// @see ext_quaternion_double_precision
typedef qua<double, highp> highp_dquat;
/// @}
} //namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_float2x3.hpp | .hpp | 466 | 19 | /// @ref core
/// @file glm/ext/matrix_float2x3.hpp
#pragma once
#include "../detail/type_mat2x3.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 2 columns of 3 components matrix of single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<2, 3, float, defaultp> mat2x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double3x2.hpp | .hpp | 469 | 19 | /// @ref core
/// @file glm/ext/matrix_double3x2.hpp
#pragma once
#include "../detail/type_mat3x2.hpp"
namespace glm
{
/// @addtogroup core_matrix
/// @{
/// 3 columns of 2 components matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mat<3, 2, double, defaultp> dmat3x2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_double1.hpp | .hpp | 811 | 32 | /// @ref ext_vector_double1
/// @file glm/ext/vector_double1.hpp
///
/// @defgroup ext_vector_double1 GLM_EXT_vector_double1
/// @ingroup ext
///
/// Exposes double-precision floating point vector type with one component.
///
/// Include <glm/ext/vector_double1.hpp> to use the features of this extension.
///
/// @see ext_vector_double1_precision extension.
/// @see ext_vector_float1 extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_dvec1 extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_double1
/// @{
/// 1 components vector of double-precision floating-point numbers.
typedef vec<1, double, defaultp> dvec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_uint_sized.hpp | .hpp | 1,436 | 71 | /// @ref ext_scalar_uint_sized
/// @file glm/ext/scalar_uint_sized.hpp
///
/// @defgroup ext_scalar_uint_sized GLM_EXT_scalar_uint_sized
/// @ingroup ext
///
/// Exposes sized unsigned integer scalar types.
///
/// Include <glm/ext/scalar_uint_sized.hpp> to use the features of this extension.
///
/// @see ext_scalar_int_sized
#pragma once
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_uint_sized extension included")
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::uint8_t uint8;
typedef std::uint16_t uint16;
typedef std::uint32_t uint32;
# else
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
#endif
template<>
struct is_int<uint8>
{
enum test {value = ~0};
};
template<>
struct is_int<uint16>
{
enum test {value = ~0};
};
template<>
struct is_int<uint64>
{
enum test {value = ~0};
};
}//namespace detail
/// @addtogroup ext_scalar_uint_sized
/// @{
/// 8 bit unsigned integer type.
typedef detail::uint8 uint8;
/// 16 bit unsigned integer type.
typedef detail::uint16 uint16;
/// 32 bit unsigned integer type.
typedef detail::uint32 uint32;
/// 64 bit unsigned integer type.
typedef detail::uint64 uint64;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double3x3_precision.hpp | .hpp | 3,019 | 50 | /// @ref core
/// @file glm/ext/matrix_double3x3_precision.hpp
#pragma once
#include "../detail/type_mat3x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, lowp> lowp_dmat3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, mediump> mediump_dmat3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, highp> highp_dmat3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, lowp> lowp_dmat3x3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, mediump> mediump_dmat3x3;
/// 3 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, highp> highp_dmat3x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_exponential.hpp | .hpp | 1,804 | 64 | /// @ref ext_quaternion_exponential
/// @file glm/ext/quaternion_exponential.hpp
///
/// @defgroup ext_quaternion_exponential GLM_EXT_quaternion_exponential
/// @ingroup ext
///
/// Provides exponential functions for quaternion types
///
/// Include <glm/ext/quaternion_exponential.hpp> to use the features of this extension.
///
/// @see core_exponential
/// @see ext_quaternion_float
/// @see ext_quaternion_double
#pragma once
// Dependency:
#include "../common.hpp"
#include "../trigonometric.hpp"
#include "../geometric.hpp"
#include "../ext/scalar_constants.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_exponential extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_transform
/// @{
/// Returns a exponential of a quaternion.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> exp(qua<T, Q> const& q);
/// Returns a logarithm of a quaternion
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> log(qua<T, Q> const& q);
/// Returns a quaternion raised to a power.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> pow(qua<T, Q> const& q, T y);
/// Returns the square root of a quaternion
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> sqrt(qua<T, Q> const& q);
/// @}
} //namespace glm
#include "quaternion_exponential.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double2x3_precision.hpp | .hpp | 1,621 | 32 | /// @ref core
/// @file glm/ext/matrix_double2x3_precision.hpp
#pragma once
#include "../detail/type_mat2x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 2 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, double, lowp> lowp_dmat2x3;
/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, double, mediump> mediump_dmat2x3;
/// 2 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, double, highp> highp_dmat2x3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int1.hpp | .hpp | 725 | 33 | /// @ref ext_vector_int1
/// @file glm/ext/vector_int1.hpp
///
/// @defgroup ext_vector_int1 GLM_EXT_vector_int1
/// @ingroup ext
///
/// Exposes ivec1 vector type.
///
/// Include <glm/ext/vector_int1.hpp> to use the features of this extension.
///
/// @see ext_vector_uint1 extension.
/// @see ext_vector_int1_precision extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_int1 extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_int1
/// @{
/// 1 component vector of signed integer numbers.
typedef vec<1, int, defaultp> ivec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/scalar_constants.hpp | .hpp | 925 | 37 | /// @ref ext_scalar_constants
/// @file glm/ext/scalar_constants.hpp
///
/// @defgroup ext_scalar_constants GLM_EXT_scalar_constants
/// @ingroup ext
///
/// Provides a list of constants and precomputed useful values.
///
/// Include <glm/ext/scalar_constants.hpp> to use the features of this extension.
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_constants extension included")
#endif
namespace glm
{
/// @addtogroup ext_scalar_constants
/// @{
/// Return the epsilon constant for floating point types.
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
/// Return the pi constant for floating point types.
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
/// @}
} //namespace glm
#include "scalar_constants.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/quaternion_trigonometric.hpp | .hpp | 1,876 | 64 | /// @ref ext_quaternion_trigonometric
/// @file glm/ext/quaternion_trigonometric.hpp
///
/// @defgroup ext_quaternion_trigonometric GLM_EXT_quaternion_trigonometric
/// @ingroup ext
///
/// Provides trigonometric functions for quaternion types
///
/// Include <glm/ext/quaternion_trigonometric.hpp> to use the features of this extension.
///
/// @see ext_quaternion_float
/// @see ext_quaternion_double
/// @see ext_quaternion_exponential
/// @see ext_quaternion_geometric
/// @see ext_quaternion_relational
/// @see ext_quaternion_transform
#pragma once
// Dependency:
#include "../trigonometric.hpp"
#include "../exponential.hpp"
#include "scalar_constants.hpp"
#include "vector_relational.hpp"
#include <limits>
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_quaternion_trigonometric extension included")
#endif
namespace glm
{
/// @addtogroup ext_quaternion_trigonometric
/// @{
/// Returns the quaternion rotation angle.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL T angle(qua<T, Q> const& x);
/// Returns the q rotation axis.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> axis(qua<T, Q> const& x);
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians.
/// @param axis Axis of the quaternion, must be normalized.
///
/// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum
template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> angleAxis(T const& angle, vec<3, T, Q> const& axis);
/// @}
} //namespace glm
#include "quaternion_trigonometric.inl"
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_bool2.hpp | .hpp | 410 | 19 | /// @ref core
/// @file glm/ext/vector_bool2.hpp
#pragma once
#include "../detail/type_vec2.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 2 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<2, bool, defaultp> bvec2;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_float1_precision.hpp | .hpp | 1,186 | 37 | /// @ref ext_vector_float1_precision
/// @file glm/ext/vector_float1_precision.hpp
///
/// @defgroup ext_vector_float1_precision GLM_EXT_vector_float1_precision
/// @ingroup ext
///
/// Exposes highp_vec1, mediump_vec1 and lowp_vec1 types.
///
/// Include <glm/ext/vector_float1_precision.hpp> to use the features of this extension.
///
/// @see ext_vector_float1 extension.
#pragma once
#include "../detail/type_vec1.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_vector_float1_precision extension included")
#endif
namespace glm
{
/// @addtogroup ext_vector_float1_precision
/// @{
/// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
typedef vec<1, float, highp> highp_vec1;
/// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
typedef vec<1, float, mediump> mediump_vec1;
/// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
typedef vec<1, float, lowp> lowp_vec1;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/vector_int3.hpp | .hpp | 423 | 19 | /// @ref core
/// @file glm/ext/vector_int3.hpp
#pragma once
#include "../detail/type_vec3.hpp"
namespace glm
{
/// @addtogroup core_vector
/// @{
/// 3 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, int, defaultp> ivec3;
/// @}
}//namespace glm
| Unknown |
3D | mcellteam/mcell | libs/glm/ext/matrix_double4x3_precision.hpp | .hpp | 1,621 | 32 | /// @ref core
/// @file glm/ext/matrix_double4x3_precision.hpp
#pragma once
#include "../detail/type_mat4x3.hpp"
namespace glm
{
/// @addtogroup core_matrix_precision
/// @{
/// 4 columns of 3 components matrix of double-precision floating-point numbers using low precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, double, lowp> lowp_dmat4x3;
/// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, double, mediump> mediump_dmat4x3;
/// 4 columns of 3 components matrix of double-precision floating-point numbers using medium precision arithmetic in term of ULPs.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, double, highp> highp_dmat4x3;
/// @}
}//namespace glm
| Unknown |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.