qualifier.hpp
#pragma once
#include "setup.hpp"
namespace glm
{
enum qualifier
{
packed_highp,
packed_mediump,
packed_lowp,
# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
aligned_highp,
aligned_mediump,
aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
aligned = aligned_highp,
# endif
highp = packed_highp,
mediump = packed_mediump,
lowp = packed_lowp,
packed = packed_highp,
# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
defaultp = aligned_highp
# else
defaultp = highp
# endif
};
typedef qualifier precision;
template<length_t L, typename T, qualifier Q = defaultp> struct vec;
template<length_t C, length_t R, typename T, qualifier Q = defaultp> struct mat;
template<typename T, qualifier Q = defaultp> struct qua;
# if GLM_HAS_TEMPLATE_ALIASES
template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
# endif
namespace detail
{
template<glm::qualifier P>
struct is_aligned
{
static const bool value = false;
};
# if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
template<>
struct is_aligned<glm::aligned_lowp>
{
static const bool value = true;
};
template<>
struct is_aligned<glm::aligned_mediump>
{
static const bool value = true;
};
template<>
struct is_aligned<glm::aligned_highp>
{
static const bool value = true;
};
# endif
template<length_t L, typename T, bool is_aligned>
struct storage
{
typedef struct type {
T data[L];
} type;
};
# if GLM_HAS_ALIGNOF
template<length_t L, typename T>
struct storage<L, T, true>
{
typedef struct alignas(L * sizeof(T)) type {
T data[L];
} type;
};
template<typename T>
struct storage<3, T, true>
{
typedef struct alignas(4 * sizeof(T)) type {
T data[4];
} type;
};
# endif
# if GLM_ARCH & GLM_ARCH_SSE2_BIT
template<>
struct storage<4, float, true>
{
typedef glm_f32vec4 type;
};
template<>
struct storage<4, int, true>
{
typedef glm_i32vec4 type;
};
template<>
struct storage<4, unsigned int, true>
{
typedef glm_u32vec4 type;
};
template<>
struct storage<3, float, true>
{
typedef glm_f32vec4 type;
};
template<>
struct storage<3, int, true>
{
typedef glm_i32vec4 type;
};
template<>
struct storage<3, unsigned int, true>
{
typedef glm_u32vec4 type;
};
template<>
struct storage<2, double, true>
{
typedef glm_f64vec2 type;
};
template<>
struct storage<2, detail::int64, true>
{
typedef glm_i64vec2 type;
};
template<>
struct storage<2, detail::uint64, true>
{
typedef glm_u64vec2 type;
};
template<>
struct storage<3, detail::uint64, true>
{
typedef glm_u64vec2 type;
};
template<>
struct storage<4, double, true>
{
# if (GLM_ARCH & GLM_ARCH_AVX_BIT)
typedef glm_f64vec4 type;
# else
struct type
{
glm_f64vec2 data[2];
GLM_CONSTEXPR glm_f64vec2 getv(int i) const {
return data[i];
}
GLM_CONSTEXPR void setv(int i, const glm_f64vec2& v) {
data[i] = v;
}
};
# endif
};
template<>
struct storage<3, double, true> : public storage<4, double, true>
{};
# endif
# if (GLM_ARCH & GLM_ARCH_AVX2_BIT)
template<>
struct storage<4, detail::int64, true>
{
typedef glm_i64vec4 type;
};
template<>
struct storage<4, detail::uint64, true>
{
typedef glm_u64vec4 type;
};
# endif
# if GLM_ARCH & GLM_ARCH_NEON_BIT
template<>
struct storage<4, float, true>
{
typedef glm_f32vec4 type;
};
template<>
struct storage<3, float, true> : public storage<4, float, true>
{};
template<>
struct storage<4, int, true>
{
typedef glm_i32vec4 type;
};
template<>
struct storage<3, int, true> : public storage<4, int, true>
{};
template<>
struct storage<4, unsigned int, true>
{
typedef glm_u32vec4 type;
};
template<>
struct storage<3, unsigned int, true> : public storage<4, unsigned int, true>
{};
# if GLM_HAS_ALIGNOF
template<>
struct storage<3, double, true>
{
typedef struct alignas(4 * sizeof(double)) type {
double data[4];
} type;
};
# endif//GLM_HAS_ALIGNOF
# endif
enum genTypeEnum
{
GENTYPE_VEC,
GENTYPE_MAT,
GENTYPE_QUAT
};
template <typename genType>
struct genTypeTrait
{};
template <length_t C, length_t R, typename T>
struct genTypeTrait<mat<C, R, T> >
{
static const genTypeEnum GENTYPE = GENTYPE_MAT;
};
template<typename genType, genTypeEnum type>
struct init_gentype
{
};
template<typename genType>
struct init_gentype<genType, GENTYPE_QUAT>
{
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
{
return genType(1, 0, 0, 0);
}
};
template<typename genType>
struct init_gentype<genType, GENTYPE_MAT>
{
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
{
return genType(1);
}
};
}//namespace detail
}//namespace glm
glm::uint64
detail::uint64 uint64
64 bit unsigned integer type.
Definition: scalar_uint_sized.hpp:67
glm::identity
GLM_FUNC_DECL GLM_CONSTEXPR genType identity()
Builds an identity matrix.
glm::int64
detail::int64 int64
64 bit signed integer type.
Definition: scalar_int_sized.hpp:67