doc/api/a00035_source.html

 #pragma once


 #include "detail/qualifier.hpp"


 namespace glm

 {

 #if GLM_HAS_EXTENDED_INTEGER_TYPE

         typedef std::int8_t                             int8;

         typedef std::int16_t                    int16;

         typedef std::int32_t                    int32;

         typedef std::int64_t                    int64;


         typedef std::uint8_t                    uint8;

         typedef std::uint16_t                   uint16;

         typedef std::uint32_t                   uint32;

         typedef std::uint64_t                   uint64;

 #else

         typedef signed char                             int8;

         typedef signed short                    int16;

         typedef signed int                              int32;

         typedef detail::int64                   int64;


         typedef unsigned char                   uint8;

         typedef unsigned short                  uint16;

         typedef unsigned int                    uint32;

         typedef detail::uint64                  uint64;

 #endif


         // Scalar int


         typedef int8                                    lowp_i8;

         typedef int8                                    mediump_i8;

         typedef int8                                    highp_i8;

         typedef int8                                    i8;


         typedef int8                                    lowp_int8;

         typedef int8                                    mediump_int8;

         typedef int8                                    highp_int8;


         typedef int8                                    lowp_int8_t;

         typedef int8                                    mediump_int8_t;

         typedef int8                                    highp_int8_t;

         typedef int8                                    int8_t;


         typedef int16                                   lowp_i16;

         typedef int16                                   mediump_i16;

         typedef int16                                   highp_i16;

         typedef int16                                   i16;


         typedef int16                                   lowp_int16;

         typedef int16                                   mediump_int16;

         typedef int16                                   highp_int16;


         typedef int16                                   lowp_int16_t;

         typedef int16                                   mediump_int16_t;

         typedef int16                                   highp_int16_t;

         typedef int16                                   int16_t;


         typedef int32                                   lowp_i32;

         typedef int32                                   mediump_i32;

         typedef int32                                   highp_i32;

         typedef int32                                   i32;


         typedef int32                                   lowp_int32;

         typedef int32                                   mediump_int32;

         typedef int32                                   highp_int32;


         typedef int32                                   lowp_int32_t;

         typedef int32                                   mediump_int32_t;

         typedef int32                                   highp_int32_t;

         typedef int32                                   int32_t;


         typedef int64                                   lowp_i64;

         typedef int64                                   mediump_i64;

         typedef int64                                   highp_i64;

         typedef int64                                   i64;


         typedef int64                                   lowp_int64;

         typedef int64                                   mediump_int64;

         typedef int64                                   highp_int64;


         typedef int64                                   lowp_int64_t;

         typedef int64                                   mediump_int64_t;

         typedef int64                                   highp_int64_t;

         typedef int64                                   int64_t;


         // Scalar uint


         typedef uint8                                   lowp_u8;

         typedef uint8                                   mediump_u8;

         typedef uint8                                   highp_u8;

         typedef uint8                                   u8;


         typedef uint8                                   lowp_uint8;

         typedef uint8                                   mediump_uint8;

         typedef uint8                                   highp_uint8;


         typedef uint8                                   lowp_uint8_t;

         typedef uint8                                   mediump_uint8_t;

         typedef uint8                                   highp_uint8_t;

         typedef uint8                                   uint8_t;


         typedef uint16                                  lowp_u16;

         typedef uint16                                  mediump_u16;

         typedef uint16                                  highp_u16;

         typedef uint16                                  u16;


         typedef uint16                                  lowp_uint16;

         typedef uint16                                  mediump_uint16;

         typedef uint16                                  highp_uint16;


         typedef uint16                                  lowp_uint16_t;

         typedef uint16                                  mediump_uint16_t;

         typedef uint16                                  highp_uint16_t;

         typedef uint16                                  uint16_t;


         typedef uint32                                  lowp_u32;

         typedef uint32                                  mediump_u32;

         typedef uint32                                  highp_u32;

         typedef uint32                                  u32;


         typedef uint32                                  lowp_uint32;

         typedef uint32                                  mediump_uint32;

         typedef uint32                                  highp_uint32;


         typedef uint32                                  lowp_uint32_t;

         typedef uint32                                  mediump_uint32_t;

         typedef uint32                                  highp_uint32_t;

         typedef uint32                                  uint32_t;


         typedef uint64                                  lowp_u64;

         typedef uint64                                  mediump_u64;

         typedef uint64                                  highp_u64;

         typedef uint64                                  u64;


         typedef uint64                                  lowp_uint64;

         typedef uint64                                  mediump_uint64;

         typedef uint64                                  highp_uint64;


         typedef uint64                                  lowp_uint64_t;

         typedef uint64                                  mediump_uint64_t;

         typedef uint64                                  highp_uint64_t;

         typedef uint64                                  uint64_t;


         // Scalar float


         typedef float                                   lowp_f32;

         typedef float                                   mediump_f32;

         typedef float                                   highp_f32;

         typedef float                                   f32;


         typedef float                                   lowp_float32;

         typedef float                                   mediump_float32;

         typedef float                                   highp_float32;

         typedef float                                   float32;


         typedef float                                   lowp_float32_t;

         typedef float                                   mediump_float32_t;

         typedef float                                   highp_float32_t;

         typedef float                                   float32_t;


         typedef double                                  lowp_f64;

         typedef double                                  mediump_f64;

         typedef double                                  highp_f64;

         typedef double                                  f64;


         typedef double                                  lowp_float64;

         typedef double                                  mediump_float64;

         typedef double                                  highp_float64;

         typedef double                                  float64;


         typedef double                                  lowp_float64_t;

         typedef double                                  mediump_float64_t;

         typedef double                                  highp_float64_t;

         typedef double                                  float64_t;


         // Vector bool


         typedef vec<1, bool, lowp>              lowp_bvec1;

         typedef vec<2, bool, lowp>              lowp_bvec2;

         typedef vec<3, bool, lowp>              lowp_bvec3;

         typedef vec<4, bool, lowp>              lowp_bvec4;


         typedef vec<1, bool, mediump>   mediump_bvec1;

         typedef vec<2, bool, mediump>   mediump_bvec2;

         typedef vec<3, bool, mediump>   mediump_bvec3;

         typedef vec<4, bool, mediump>   mediump_bvec4;


         typedef vec<1, bool, highp>             highp_bvec1;

         typedef vec<2, bool, highp>             highp_bvec2;

         typedef vec<3, bool, highp>             highp_bvec3;

         typedef vec<4, bool, highp>             highp_bvec4;


         typedef vec<1, bool, defaultp>  bvec1;

         typedef vec<2, bool, defaultp>  bvec2;

         typedef vec<3, bool, defaultp>  bvec3;

         typedef vec<4, bool, defaultp>  bvec4;


         // Vector int


         typedef vec<1, i32, lowp>               lowp_ivec1;

         typedef vec<2, i32, lowp>               lowp_ivec2;

         typedef vec<3, i32, lowp>               lowp_ivec3;

         typedef vec<4, i32, lowp>               lowp_ivec4;


         typedef vec<1, i32, mediump>    mediump_ivec1;

         typedef vec<2, i32, mediump>    mediump_ivec2;

         typedef vec<3, i32, mediump>    mediump_ivec3;

         typedef vec<4, i32, mediump>    mediump_ivec4;


         typedef vec<1, i32, highp>              highp_ivec1;

         typedef vec<2, i32, highp>              highp_ivec2;

         typedef vec<3, i32, highp>              highp_ivec3;

         typedef vec<4, i32, highp>              highp_ivec4;


         typedef vec<1, i32, defaultp>   ivec1;

         typedef vec<2, i32, defaultp>   ivec2;

         typedef vec<3, i32, defaultp>   ivec3;

         typedef vec<4, i32, defaultp>   ivec4;


         typedef vec<1, i8, lowp>                lowp_i8vec1;

         typedef vec<2, i8, lowp>                lowp_i8vec2;

         typedef vec<3, i8, lowp>                lowp_i8vec3;

         typedef vec<4, i8, lowp>                lowp_i8vec4;


         typedef vec<1, i8, mediump>             mediump_i8vec1;

         typedef vec<2, i8, mediump>             mediump_i8vec2;

         typedef vec<3, i8, mediump>             mediump_i8vec3;

         typedef vec<4, i8, mediump>             mediump_i8vec4;


         typedef vec<1, i8, highp>               highp_i8vec1;

         typedef vec<2, i8, highp>               highp_i8vec2;

         typedef vec<3, i8, highp>               highp_i8vec3;

         typedef vec<4, i8, highp>               highp_i8vec4;


         typedef vec<1, i8, defaultp>    i8vec1;

         typedef vec<2, i8, defaultp>    i8vec2;

         typedef vec<3, i8, defaultp>    i8vec3;

         typedef vec<4, i8, defaultp>    i8vec4;


         typedef vec<1, i16, lowp>               lowp_i16vec1;

         typedef vec<2, i16, lowp>               lowp_i16vec2;

         typedef vec<3, i16, lowp>               lowp_i16vec3;

         typedef vec<4, i16, lowp>               lowp_i16vec4;


         typedef vec<1, i16, mediump>    mediump_i16vec1;

         typedef vec<2, i16, mediump>    mediump_i16vec2;

         typedef vec<3, i16, mediump>    mediump_i16vec3;

         typedef vec<4, i16, mediump>    mediump_i16vec4;


         typedef vec<1, i16, highp>              highp_i16vec1;

         typedef vec<2, i16, highp>              highp_i16vec2;

         typedef vec<3, i16, highp>              highp_i16vec3;

         typedef vec<4, i16, highp>              highp_i16vec4;


         typedef vec<1, i16, defaultp>   i16vec1;

         typedef vec<2, i16, defaultp>   i16vec2;

         typedef vec<3, i16, defaultp>   i16vec3;

         typedef vec<4, i16, defaultp>   i16vec4;


         typedef vec<1, i32, lowp>               lowp_i32vec1;

         typedef vec<2, i32, lowp>               lowp_i32vec2;

         typedef vec<3, i32, lowp>               lowp_i32vec3;

         typedef vec<4, i32, lowp>               lowp_i32vec4;


         typedef vec<1, i32, mediump>    mediump_i32vec1;

         typedef vec<2, i32, mediump>    mediump_i32vec2;

         typedef vec<3, i32, mediump>    mediump_i32vec3;

         typedef vec<4, i32, mediump>    mediump_i32vec4;


         typedef vec<1, i32, highp>              highp_i32vec1;

         typedef vec<2, i32, highp>              highp_i32vec2;

         typedef vec<3, i32, highp>              highp_i32vec3;

         typedef vec<4, i32, highp>              highp_i32vec4;


         typedef vec<1, i32, defaultp>   i32vec1;

         typedef vec<2, i32, defaultp>   i32vec2;

         typedef vec<3, i32, defaultp>   i32vec3;

         typedef vec<4, i32, defaultp>   i32vec4;


         typedef vec<1, i64, lowp>               lowp_i64vec1;

         typedef vec<2, i64, lowp>               lowp_i64vec2;

         typedef vec<3, i64, lowp>               lowp_i64vec3;

         typedef vec<4, i64, lowp>               lowp_i64vec4;


         typedef vec<1, i64, mediump>    mediump_i64vec1;

         typedef vec<2, i64, mediump>    mediump_i64vec2;

         typedef vec<3, i64, mediump>    mediump_i64vec3;

         typedef vec<4, i64, mediump>    mediump_i64vec4;


         typedef vec<1, i64, highp>              highp_i64vec1;

         typedef vec<2, i64, highp>              highp_i64vec2;

         typedef vec<3, i64, highp>              highp_i64vec3;

         typedef vec<4, i64, highp>              highp_i64vec4;


         typedef vec<1, i64, defaultp>   i64vec1;

         typedef vec<2, i64, defaultp>   i64vec2;

         typedef vec<3, i64, defaultp>   i64vec3;

         typedef vec<4, i64, defaultp>   i64vec4;


         // Vector uint


         typedef vec<1, u32, lowp>               lowp_uvec1;

         typedef vec<2, u32, lowp>               lowp_uvec2;

         typedef vec<3, u32, lowp>               lowp_uvec3;

         typedef vec<4, u32, lowp>               lowp_uvec4;


         typedef vec<1, u32, mediump>    mediump_uvec1;

         typedef vec<2, u32, mediump>    mediump_uvec2;

         typedef vec<3, u32, mediump>    mediump_uvec3;

         typedef vec<4, u32, mediump>    mediump_uvec4;


         typedef vec<1, u32, highp>              highp_uvec1;

         typedef vec<2, u32, highp>              highp_uvec2;

         typedef vec<3, u32, highp>              highp_uvec3;

         typedef vec<4, u32, highp>              highp_uvec4;


         typedef vec<1, u32, defaultp>   uvec1;

         typedef vec<2, u32, defaultp>   uvec2;

         typedef vec<3, u32, defaultp>   uvec3;

         typedef vec<4, u32, defaultp>   uvec4;


         typedef vec<1, u8, lowp>                lowp_u8vec1;

         typedef vec<2, u8, lowp>                lowp_u8vec2;

         typedef vec<3, u8, lowp>                lowp_u8vec3;

         typedef vec<4, u8, lowp>                lowp_u8vec4;


         typedef vec<1, u8, mediump>             mediump_u8vec1;

         typedef vec<2, u8, mediump>             mediump_u8vec2;

         typedef vec<3, u8, mediump>             mediump_u8vec3;

         typedef vec<4, u8, mediump>             mediump_u8vec4;


         typedef vec<1, u8, highp>               highp_u8vec1;

         typedef vec<2, u8, highp>               highp_u8vec2;

         typedef vec<3, u8, highp>               highp_u8vec3;

         typedef vec<4, u8, highp>               highp_u8vec4;


         typedef vec<1, u8, defaultp>    u8vec1;

         typedef vec<2, u8, defaultp>    u8vec2;

         typedef vec<3, u8, defaultp>    u8vec3;

         typedef vec<4, u8, defaultp>    u8vec4;


         typedef vec<1, u16, lowp>               lowp_u16vec1;

         typedef vec<2, u16, lowp>               lowp_u16vec2;

         typedef vec<3, u16, lowp>               lowp_u16vec3;

         typedef vec<4, u16, lowp>               lowp_u16vec4;


         typedef vec<1, u16, mediump>    mediump_u16vec1;

         typedef vec<2, u16, mediump>    mediump_u16vec2;

         typedef vec<3, u16, mediump>    mediump_u16vec3;

         typedef vec<4, u16, mediump>    mediump_u16vec4;


         typedef vec<1, u16, highp>              highp_u16vec1;

         typedef vec<2, u16, highp>              highp_u16vec2;

         typedef vec<3, u16, highp>              highp_u16vec3;

         typedef vec<4, u16, highp>              highp_u16vec4;


         typedef vec<1, u16, defaultp>   u16vec1;

         typedef vec<2, u16, defaultp>   u16vec2;

         typedef vec<3, u16, defaultp>   u16vec3;

         typedef vec<4, u16, defaultp>   u16vec4;


         typedef vec<1, u32, lowp>               lowp_u32vec1;

         typedef vec<2, u32, lowp>               lowp_u32vec2;

         typedef vec<3, u32, lowp>               lowp_u32vec3;

         typedef vec<4, u32, lowp>               lowp_u32vec4;


         typedef vec<1, u32, mediump>    mediump_u32vec1;

         typedef vec<2, u32, mediump>    mediump_u32vec2;

         typedef vec<3, u32, mediump>    mediump_u32vec3;

         typedef vec<4, u32, mediump>    mediump_u32vec4;


         typedef vec<1, u32, highp>              highp_u32vec1;

         typedef vec<2, u32, highp>              highp_u32vec2;

         typedef vec<3, u32, highp>              highp_u32vec3;

         typedef vec<4, u32, highp>              highp_u32vec4;


         typedef vec<1, u32, defaultp>   u32vec1;

         typedef vec<2, u32, defaultp>   u32vec2;

         typedef vec<3, u32, defaultp>   u32vec3;

         typedef vec<4, u32, defaultp>   u32vec4;


         typedef vec<1, u64, lowp>               lowp_u64vec1;

         typedef vec<2, u64, lowp>               lowp_u64vec2;

         typedef vec<3, u64, lowp>               lowp_u64vec3;

         typedef vec<4, u64, lowp>               lowp_u64vec4;


         typedef vec<1, u64, mediump>    mediump_u64vec1;

         typedef vec<2, u64, mediump>    mediump_u64vec2;

         typedef vec<3, u64, mediump>    mediump_u64vec3;

         typedef vec<4, u64, mediump>    mediump_u64vec4;


         typedef vec<1, u64, highp>              highp_u64vec1;

         typedef vec<2, u64, highp>              highp_u64vec2;

         typedef vec<3, u64, highp>              highp_u64vec3;

         typedef vec<4, u64, highp>              highp_u64vec4;


         typedef vec<1, u64, defaultp>   u64vec1;

         typedef vec<2, u64, defaultp>   u64vec2;

         typedef vec<3, u64, defaultp>   u64vec3;

         typedef vec<4, u64, defaultp>   u64vec4;


         // Vector float


         typedef vec<1, float, lowp>                     lowp_vec1;

         typedef vec<2, float, lowp>                     lowp_vec2;

         typedef vec<3, float, lowp>                     lowp_vec3;

         typedef vec<4, float, lowp>                     lowp_vec4;


         typedef vec<1, float, mediump>          mediump_vec1;

         typedef vec<2, float, mediump>          mediump_vec2;

         typedef vec<3, float, mediump>          mediump_vec3;

         typedef vec<4, float, mediump>          mediump_vec4;


         typedef vec<1, float, highp>            highp_vec1;

         typedef vec<2, float, highp>            highp_vec2;

         typedef vec<3, float, highp>            highp_vec3;

         typedef vec<4, float, highp>            highp_vec4;


         typedef vec<1, float, defaultp>         vec1;

         typedef vec<2, float, defaultp>         vec2;

         typedef vec<3, float, defaultp>         vec3;

         typedef vec<4, float, defaultp>         vec4;


         typedef vec<1, float, lowp>                     lowp_fvec1;

         typedef vec<2, float, lowp>                     lowp_fvec2;

         typedef vec<3, float, lowp>                     lowp_fvec3;

         typedef vec<4, float, lowp>                     lowp_fvec4;


         typedef vec<1, float, mediump>          mediump_fvec1;

         typedef vec<2, float, mediump>          mediump_fvec2;

         typedef vec<3, float, mediump>          mediump_fvec3;

         typedef vec<4, float, mediump>          mediump_fvec4;


         typedef vec<1, float, highp>            highp_fvec1;

         typedef vec<2, float, highp>            highp_fvec2;

         typedef vec<3, float, highp>            highp_fvec3;

         typedef vec<4, float, highp>            highp_fvec4;


         typedef vec<1, f32, defaultp>           fvec1;

         typedef vec<2, f32, defaultp>           fvec2;

         typedef vec<3, f32, defaultp>           fvec3;

         typedef vec<4, f32, defaultp>           fvec4;


         typedef vec<1, f32, lowp>                       lowp_f32vec1;

         typedef vec<2, f32, lowp>                       lowp_f32vec2;

         typedef vec<3, f32, lowp>                       lowp_f32vec3;

         typedef vec<4, f32, lowp>                       lowp_f32vec4;


         typedef vec<1, f32, mediump>            mediump_f32vec1;

         typedef vec<2, f32, mediump>            mediump_f32vec2;

         typedef vec<3, f32, mediump>            mediump_f32vec3;

         typedef vec<4, f32, mediump>            mediump_f32vec4;


         typedef vec<1, f32, highp>                      highp_f32vec1;

         typedef vec<2, f32, highp>                      highp_f32vec2;

         typedef vec<3, f32, highp>                      highp_f32vec3;

         typedef vec<4, f32, highp>                      highp_f32vec4;


         typedef vec<1, f32, defaultp>           f32vec1;

         typedef vec<2, f32, defaultp>           f32vec2;

         typedef vec<3, f32, defaultp>           f32vec3;

         typedef vec<4, f32, defaultp>           f32vec4;


         typedef vec<1, f64, lowp>                       lowp_dvec1;

         typedef vec<2, f64, lowp>                       lowp_dvec2;

         typedef vec<3, f64, lowp>                       lowp_dvec3;

         typedef vec<4, f64, lowp>                       lowp_dvec4;


         typedef vec<1, f64, mediump>            mediump_dvec1;

         typedef vec<2, f64, mediump>            mediump_dvec2;

         typedef vec<3, f64, mediump>            mediump_dvec3;

         typedef vec<4, f64, mediump>            mediump_dvec4;


         typedef vec<1, f64, highp>                      highp_dvec1;

         typedef vec<2, f64, highp>                      highp_dvec2;

         typedef vec<3, f64, highp>                      highp_dvec3;

         typedef vec<4, f64, highp>                      highp_dvec4;


         typedef vec<1, f64, defaultp>           dvec1;

         typedef vec<2, f64, defaultp>           dvec2;

         typedef vec<3, f64, defaultp>           dvec3;

         typedef vec<4, f64, defaultp>           dvec4;


         typedef vec<1, f64, lowp>                       lowp_f64vec1;

         typedef vec<2, f64, lowp>                       lowp_f64vec2;

         typedef vec<3, f64, lowp>                       lowp_f64vec3;

         typedef vec<4, f64, lowp>                       lowp_f64vec4;


         typedef vec<1, f64, mediump>            mediump_f64vec1;

         typedef vec<2, f64, mediump>            mediump_f64vec2;

         typedef vec<3, f64, mediump>            mediump_f64vec3;

         typedef vec<4, f64, mediump>            mediump_f64vec4;


         typedef vec<1, f64, highp>                      highp_f64vec1;

         typedef vec<2, f64, highp>                      highp_f64vec2;

         typedef vec<3, f64, highp>                      highp_f64vec3;

         typedef vec<4, f64, highp>                      highp_f64vec4;


         typedef vec<1, f64, defaultp>           f64vec1;

         typedef vec<2, f64, defaultp>           f64vec2;

         typedef vec<3, f64, defaultp>           f64vec3;

         typedef vec<4, f64, defaultp>           f64vec4;


         // Matrix NxN


         typedef mat<2, 2, f32, lowp>            lowp_mat2;

         typedef mat<3, 3, f32, lowp>            lowp_mat3;

         typedef mat<4, 4, f32, lowp>            lowp_mat4;


         typedef mat<2, 2, f32, mediump>         mediump_mat2;

         typedef mat<3, 3, f32, mediump>         mediump_mat3;

         typedef mat<4, 4, f32, mediump>         mediump_mat4;


         typedef mat<2, 2, f32, highp>           highp_mat2;

         typedef mat<3, 3, f32, highp>           highp_mat3;

         typedef mat<4, 4, f32, highp>           highp_mat4;


         typedef mat<2, 2, f32, defaultp>        mat2;

         typedef mat<3, 3, f32, defaultp>        mat3;

         typedef mat<4, 4, f32, defaultp>        mat4;


         typedef mat<2, 2, f32, lowp>            lowp_fmat2;

         typedef mat<3, 3, f32, lowp>            lowp_fmat3;

         typedef mat<4, 4, f32, lowp>            lowp_fmat4;


         typedef mat<2, 2, f32, mediump>         mediump_fmat2;

         typedef mat<3, 3, f32, mediump>         mediump_fmat3;

         typedef mat<4, 4, f32, mediump>         mediump_fmat4;


         typedef mat<2, 2, f32, highp>           highp_fmat2;

         typedef mat<3, 3, f32, highp>           highp_fmat3;

         typedef mat<4, 4, f32, highp>           highp_fmat4;


         typedef mat<2, 2, f32, defaultp>        fmat2;

         typedef mat<3, 3, f32, defaultp>        fmat3;

         typedef mat<4, 4, f32, defaultp>        fmat4;


         typedef mat<2, 2, f32, lowp>            lowp_f32mat2;

         typedef mat<3, 3, f32, lowp>            lowp_f32mat3;

         typedef mat<4, 4, f32, lowp>            lowp_f32mat4;


         typedef mat<2, 2, f32, mediump>         mediump_f32mat2;

         typedef mat<3, 3, f32, mediump>         mediump_f32mat3;

         typedef mat<4, 4, f32, mediump>         mediump_f32mat4;


         typedef mat<2, 2, f32, highp>           highp_f32mat2;

         typedef mat<3, 3, f32, highp>           highp_f32mat3;

         typedef mat<4, 4, f32, highp>           highp_f32mat4;


         typedef mat<2, 2, f32, defaultp>        f32mat2;

         typedef mat<3, 3, f32, defaultp>        f32mat3;

         typedef mat<4, 4, f32, defaultp>        f32mat4;


         typedef mat<2, 2, f64, lowp>            lowp_dmat2;

         typedef mat<3, 3, f64, lowp>            lowp_dmat3;

         typedef mat<4, 4, f64, lowp>            lowp_dmat4;


         typedef mat<2, 2, f64, mediump>         mediump_dmat2;

         typedef mat<3, 3, f64, mediump>         mediump_dmat3;

         typedef mat<4, 4, f64, mediump>         mediump_dmat4;


         typedef mat<2, 2, f64, highp>           highp_dmat2;

         typedef mat<3, 3, f64, highp>           highp_dmat3;

         typedef mat<4, 4, f64, highp>           highp_dmat4;


         typedef mat<2, 2, f64, defaultp>        dmat2;

         typedef mat<3, 3, f64, defaultp>        dmat3;

         typedef mat<4, 4, f64, defaultp>        dmat4;


         typedef mat<2, 2, f64, lowp>            lowp_f64mat2;

         typedef mat<3, 3, f64, lowp>            lowp_f64mat3;

         typedef mat<4, 4, f64, lowp>            lowp_f64mat4;


         typedef mat<2, 2, f64, mediump>         mediump_f64mat2;

         typedef mat<3, 3, f64, mediump>         mediump_f64mat3;

         typedef mat<4, 4, f64, mediump>         mediump_f64mat4;


         typedef mat<2, 2, f64, highp>           highp_f64mat2;

         typedef mat<3, 3, f64, highp>           highp_f64mat3;

         typedef mat<4, 4, f64, highp>           highp_f64mat4;


         typedef mat<2, 2, f64, defaultp>        f64mat2;

         typedef mat<3, 3, f64, defaultp>        f64mat3;

         typedef mat<4, 4, f64, defaultp>        f64mat4;


         // Matrix MxN


         typedef mat<2, 2, f32, lowp>            lowp_mat2x2;

         typedef mat<2, 3, f32, lowp>            lowp_mat2x3;

         typedef mat<2, 4, f32, lowp>            lowp_mat2x4;

         typedef mat<3, 2, f32, lowp>            lowp_mat3x2;

         typedef mat<3, 3, f32, lowp>            lowp_mat3x3;

         typedef mat<3, 4, f32, lowp>            lowp_mat3x4;

         typedef mat<4, 2, f32, lowp>            lowp_mat4x2;

         typedef mat<4, 3, f32, lowp>            lowp_mat4x3;

         typedef mat<4, 4, f32, lowp>            lowp_mat4x4;


         typedef mat<2, 2, f32, mediump>         mediump_mat2x2;

         typedef mat<2, 3, f32, mediump>         mediump_mat2x3;

         typedef mat<2, 4, f32, mediump>         mediump_mat2x4;

         typedef mat<3, 2, f32, mediump>         mediump_mat3x2;

         typedef mat<3, 3, f32, mediump>         mediump_mat3x3;

         typedef mat<3, 4, f32, mediump>         mediump_mat3x4;

         typedef mat<4, 2, f32, mediump>         mediump_mat4x2;

         typedef mat<4, 3, f32, mediump>         mediump_mat4x3;

         typedef mat<4, 4, f32, mediump>         mediump_mat4x4;


         typedef mat<2, 2, f32, highp>           highp_mat2x2;

         typedef mat<2, 3, f32, highp>           highp_mat2x3;

         typedef mat<2, 4, f32, highp>           highp_mat2x4;

         typedef mat<3, 2, f32, highp>           highp_mat3x2;

         typedef mat<3, 3, f32, highp>           highp_mat3x3;

         typedef mat<3, 4, f32, highp>           highp_mat3x4;

         typedef mat<4, 2, f32, highp>           highp_mat4x2;

         typedef mat<4, 3, f32, highp>           highp_mat4x3;

         typedef mat<4, 4, f32, highp>           highp_mat4x4;


         typedef mat<2, 2, f32, defaultp>        mat2x2;

         typedef mat<3, 2, f32, defaultp>        mat3x2;

         typedef mat<4, 2, f32, defaultp>        mat4x2;

         typedef mat<2, 3, f32, defaultp>        mat2x3;

         typedef mat<3, 3, f32, defaultp>        mat3x3;

         typedef mat<4, 3, f32, defaultp>        mat4x3;

         typedef mat<2, 4, f32, defaultp>        mat2x4;

         typedef mat<3, 4, f32, defaultp>        mat3x4;

         typedef mat<4, 4, f32, defaultp>        mat4x4;


         typedef mat<2, 2, f32, lowp>            lowp_fmat2x2;

         typedef mat<2, 3, f32, lowp>            lowp_fmat2x3;

         typedef mat<2, 4, f32, lowp>            lowp_fmat2x4;

         typedef mat<3, 2, f32, lowp>            lowp_fmat3x2;

         typedef mat<3, 3, f32, lowp>            lowp_fmat3x3;

         typedef mat<3, 4, f32, lowp>            lowp_fmat3x4;

         typedef mat<4, 2, f32, lowp>            lowp_fmat4x2;

         typedef mat<4, 3, f32, lowp>            lowp_fmat4x3;

         typedef mat<4, 4, f32, lowp>            lowp_fmat4x4;


         typedef mat<2, 2, f32, mediump>         mediump_fmat2x2;

         typedef mat<2, 3, f32, mediump>         mediump_fmat2x3;

         typedef mat<2, 4, f32, mediump>         mediump_fmat2x4;

         typedef mat<3, 2, f32, mediump>         mediump_fmat3x2;

         typedef mat<3, 3, f32, mediump>         mediump_fmat3x3;

         typedef mat<3, 4, f32, mediump>         mediump_fmat3x4;

         typedef mat<4, 2, f32, mediump>         mediump_fmat4x2;

         typedef mat<4, 3, f32, mediump>         mediump_fmat4x3;

         typedef mat<4, 4, f32, mediump>         mediump_fmat4x4;


         typedef mat<2, 2, f32, highp>           highp_fmat2x2;

         typedef mat<2, 3, f32, highp>           highp_fmat2x3;

         typedef mat<2, 4, f32, highp>           highp_fmat2x4;

         typedef mat<3, 2, f32, highp>           highp_fmat3x2;

         typedef mat<3, 3, f32, highp>           highp_fmat3x3;

         typedef mat<3, 4, f32, highp>           highp_fmat3x4;

         typedef mat<4, 2, f32, highp>           highp_fmat4x2;

         typedef mat<4, 3, f32, highp>           highp_fmat4x3;

         typedef mat<4, 4, f32, highp>           highp_fmat4x4;


         typedef mat<2, 2, f32, defaultp>        fmat2x2;

         typedef mat<3, 2, f32, defaultp>        fmat3x2;

         typedef mat<4, 2, f32, defaultp>        fmat4x2;

         typedef mat<2, 3, f32, defaultp>        fmat2x3;

         typedef mat<3, 3, f32, defaultp>        fmat3x3;

         typedef mat<4, 3, f32, defaultp>        fmat4x3;

         typedef mat<2, 4, f32, defaultp>        fmat2x4;

         typedef mat<3, 4, f32, defaultp>        fmat3x4;

         typedef mat<4, 4, f32, defaultp>        fmat4x4;


         typedef mat<2, 2, f32, lowp>            lowp_f32mat2x2;

         typedef mat<2, 3, f32, lowp>            lowp_f32mat2x3;

         typedef mat<2, 4, f32, lowp>            lowp_f32mat2x4;

         typedef mat<3, 2, f32, lowp>            lowp_f32mat3x2;

         typedef mat<3, 3, f32, lowp>            lowp_f32mat3x3;

         typedef mat<3, 4, f32, lowp>            lowp_f32mat3x4;

         typedef mat<4, 2, f32, lowp>            lowp_f32mat4x2;

         typedef mat<4, 3, f32, lowp>            lowp_f32mat4x3;

         typedef mat<4, 4, f32, lowp>            lowp_f32mat4x4;


         typedef mat<2, 2, f32, mediump>         mediump_f32mat2x2;

         typedef mat<2, 3, f32, mediump>         mediump_f32mat2x3;

         typedef mat<2, 4, f32, mediump>         mediump_f32mat2x4;

         typedef mat<3, 2, f32, mediump>         mediump_f32mat3x2;

         typedef mat<3, 3, f32, mediump>         mediump_f32mat3x3;

         typedef mat<3, 4, f32, mediump>         mediump_f32mat3x4;

         typedef mat<4, 2, f32, mediump>         mediump_f32mat4x2;

         typedef mat<4, 3, f32, mediump>         mediump_f32mat4x3;

         typedef mat<4, 4, f32, mediump>         mediump_f32mat4x4;


         typedef mat<2, 2, f32, highp>           highp_f32mat2x2;

         typedef mat<2, 3, f32, highp>           highp_f32mat2x3;

         typedef mat<2, 4, f32, highp>           highp_f32mat2x4;

         typedef mat<3, 2, f32, highp>           highp_f32mat3x2;

         typedef mat<3, 3, f32, highp>           highp_f32mat3x3;

         typedef mat<3, 4, f32, highp>           highp_f32mat3x4;

         typedef mat<4, 2, f32, highp>           highp_f32mat4x2;

         typedef mat<4, 3, f32, highp>           highp_f32mat4x3;

         typedef mat<4, 4, f32, highp>           highp_f32mat4x4;


         typedef mat<2, 2, f32, defaultp>        f32mat2x2;

         typedef mat<3, 2, f32, defaultp>        f32mat3x2;

         typedef mat<4, 2, f32, defaultp>        f32mat4x2;

         typedef mat<2, 3, f32, defaultp>        f32mat2x3;

         typedef mat<3, 3, f32, defaultp>        f32mat3x3;

         typedef mat<4, 3, f32, defaultp>        f32mat4x3;

         typedef mat<2, 4, f32, defaultp>        f32mat2x4;

         typedef mat<3, 4, f32, defaultp>        f32mat3x4;

         typedef mat<4, 4, f32, defaultp>        f32mat4x4;


         typedef mat<2, 2, double, lowp>         lowp_dmat2x2;

         typedef mat<2, 3, double, lowp>         lowp_dmat2x3;

         typedef mat<2, 4, double, lowp>         lowp_dmat2x4;

         typedef mat<3, 2, double, lowp>         lowp_dmat3x2;

         typedef mat<3, 3, double, lowp>         lowp_dmat3x3;

         typedef mat<3, 4, double, lowp>         lowp_dmat3x4;

         typedef mat<4, 2, double, lowp>         lowp_dmat4x2;

         typedef mat<4, 3, double, lowp>         lowp_dmat4x3;

         typedef mat<4, 4, double, lowp>         lowp_dmat4x4;


         typedef mat<2, 2, double, mediump>      mediump_dmat2x2;

         typedef mat<2, 3, double, mediump>      mediump_dmat2x3;

         typedef mat<2, 4, double, mediump>      mediump_dmat2x4;

         typedef mat<3, 2, double, mediump>      mediump_dmat3x2;

         typedef mat<3, 3, double, mediump>      mediump_dmat3x3;

         typedef mat<3, 4, double, mediump>      mediump_dmat3x4;

         typedef mat<4, 2, double, mediump>      mediump_dmat4x2;

         typedef mat<4, 3, double, mediump>      mediump_dmat4x3;

         typedef mat<4, 4, double, mediump>      mediump_dmat4x4;


         typedef mat<2, 2, double, highp>        highp_dmat2x2;

         typedef mat<2, 3, double, highp>        highp_dmat2x3;

         typedef mat<2, 4, double, highp>        highp_dmat2x4;

         typedef mat<3, 2, double, highp>        highp_dmat3x2;

         typedef mat<3, 3, double, highp>        highp_dmat3x3;

         typedef mat<3, 4, double, highp>        highp_dmat3x4;

         typedef mat<4, 2, double, highp>        highp_dmat4x2;

         typedef mat<4, 3, double, highp>        highp_dmat4x3;

         typedef mat<4, 4, double, highp>        highp_dmat4x4;


         typedef mat<2, 2, double, defaultp>     dmat2x2;

         typedef mat<3, 2, double, defaultp>     dmat3x2;

         typedef mat<4, 2, double, defaultp>     dmat4x2;

         typedef mat<2, 3, double, defaultp>     dmat2x3;

         typedef mat<3, 3, double, defaultp>     dmat3x3;

         typedef mat<4, 3, double, defaultp>     dmat4x3;

         typedef mat<2, 4, double, defaultp>     dmat2x4;

         typedef mat<3, 4, double, defaultp>     dmat3x4;

         typedef mat<4, 4, double, defaultp>     dmat4x4;


         typedef mat<2, 2, f64, lowp>            lowp_f64mat2x2;

         typedef mat<2, 3, f64, lowp>            lowp_f64mat2x3;

         typedef mat<2, 4, f64, lowp>            lowp_f64mat2x4;

         typedef mat<3, 2, f64, lowp>            lowp_f64mat3x2;

         typedef mat<3, 3, f64, lowp>            lowp_f64mat3x3;

         typedef mat<3, 4, f64, lowp>            lowp_f64mat3x4;

         typedef mat<4, 2, f64, lowp>            lowp_f64mat4x2;

         typedef mat<4, 3, f64, lowp>            lowp_f64mat4x3;

         typedef mat<4, 4, f64, lowp>            lowp_f64mat4x4;


         typedef mat<2, 2, f64, mediump>         mediump_f64mat2x2;

         typedef mat<2, 3, f64, mediump>         mediump_f64mat2x3;

         typedef mat<2, 4, f64, mediump>         mediump_f64mat2x4;

         typedef mat<3, 2, f64, mediump>         mediump_f64mat3x2;

         typedef mat<3, 3, f64, mediump>         mediump_f64mat3x3;

         typedef mat<3, 4, f64, mediump>         mediump_f64mat3x4;

         typedef mat<4, 2, f64, mediump>         mediump_f64mat4x2;

         typedef mat<4, 3, f64, mediump>         mediump_f64mat4x3;

         typedef mat<4, 4, f64, mediump>         mediump_f64mat4x4;


         typedef mat<2, 2, f64, highp>           highp_f64mat2x2;

         typedef mat<2, 3, f64, highp>           highp_f64mat2x3;

         typedef mat<2, 4, f64, highp>           highp_f64mat2x4;

         typedef mat<3, 2, f64, highp>           highp_f64mat3x2;

         typedef mat<3, 3, f64, highp>           highp_f64mat3x3;

         typedef mat<3, 4, f64, highp>           highp_f64mat3x4;

         typedef mat<4, 2, f64, highp>           highp_f64mat4x2;

         typedef mat<4, 3, f64, highp>           highp_f64mat4x3;

         typedef mat<4, 4, f64, highp>           highp_f64mat4x4;


         typedef mat<2, 2, f64, defaultp>        f64mat2x2;

         typedef mat<3, 2, f64, defaultp>        f64mat3x2;

         typedef mat<4, 2, f64, defaultp>        f64mat4x2;

         typedef mat<2, 3, f64, defaultp>        f64mat2x3;

         typedef mat<3, 3, f64, defaultp>        f64mat3x3;

         typedef mat<4, 3, f64, defaultp>        f64mat4x3;

         typedef mat<2, 4, f64, defaultp>        f64mat2x4;

         typedef mat<3, 4, f64, defaultp>        f64mat3x4;

         typedef mat<4, 4, f64, defaultp>        f64mat4x4;


         // Quaternion


         typedef qua<float, lowp>                        lowp_quat;

         typedef qua<float, mediump>                     mediump_quat;

         typedef qua<float, highp>                       highp_quat;

         typedef qua<float, defaultp>            quat;


         typedef qua<float, lowp>                        lowp_fquat;

         typedef qua<float, mediump>                     mediump_fquat;

         typedef qua<float, highp>                       highp_fquat;

         typedef qua<float, defaultp>            fquat;


         typedef qua<f32, lowp>                          lowp_f32quat;

         typedef qua<f32, mediump>                       mediump_f32quat;

         typedef qua<f32, highp>                         highp_f32quat;

         typedef qua<f32, defaultp>                      f32quat;


         typedef qua<double, lowp>                       lowp_dquat;

         typedef qua<double, mediump>            mediump_dquat;

         typedef qua<double, highp>                      highp_dquat;

         typedef qua<double, defaultp>           dquat;


         typedef qua<f64, lowp>                          lowp_f64quat;

         typedef qua<f64, mediump>                       mediump_f64quat;

         typedef qua<f64, highp>                         highp_f64quat;

         typedef qua<f64, defaultp>                      f64quat;

 }//namespace glm


glm::highp_u16vec1
vec< 1, u16, highp > highp_u16vec1
High qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:354

glm::mediump_mat4x2
mat< 4, 2, float, mediump > mediump_mat4x2
4 columns of 2 components matrix of single-precision floating-point numbers using medium precision ar...
Definition: matrix_float4x2_precision.hpp:22

glm::highp_f32mat4x2
mat< 4, 2, f32, highp > highp_f32mat4x2
High single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:696

glm::highp_mat4x3
mat< 4, 3, float, highp > highp_mat4x3
4 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
Definition: matrix_float4x3_precision.hpp:28

glm::mat4x4
mat< 4, 4, float, defaultp > mat4x4
4 columns of 4 components matrix of single-precision floating-point numbers.
Definition: matrix_float4x4.hpp:15

glm::mediump_uvec4
vec< 4, unsigned int, mediump > mediump_uvec4
4 components vector of medium qualifier unsigned integer numbers.
Definition: vector_uint4_precision.hpp:22

glm::highp_u64
uint64 highp_u64
High qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:133

glm::mediump_f64vec1
vec< 1, f64, mediump > mediump_f64vec1
Medium double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:491

glm::f32vec3
vec< 3, f32, defaultp > f32vec3
Single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:463

glm::mediump_fmat2
mat< 2, 2, f32, mediump > mediump_fmat2
Medium single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:528

glm::highp_float64_t
double highp_float64_t
High 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:175

glm::f64mat4
mat< 4, 4, f64, defaultp > f64mat4
Double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:586

glm::mediump_ivec1
vec< 1, int, mediump > mediump_ivec1
1 component vector of signed integer values.
Definition: vector_int1_precision.hpp:28

glm::mediump_dvec4
vec< 4, double, mediump > mediump_dvec4
4 components vector of medium double-qualifier floating-point numbers.
Definition: vector_double4_precision.hpp:25

glm::highp_vec3
vec< 3, float, highp > highp_vec3
3 components vector of high single-qualifier floating-point numbers.
Definition: vector_float3_precision.hpp:16

glm::lowp_dmat4x2
mat< 4, 2, double, lowp > lowp_dmat4x2
4 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
Definition: matrix_double4x2_precision.hpp:16

glm::mat2x2
mat< 2, 2, float, defaultp > mat2x2
2 columns of 2 components matrix of single-precision floating-point numbers.
Definition: matrix_float2x2.hpp:15

glm::f64mat2
mat< 2, 2, f64, defaultp > f64mat2
Double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:584

glm::mediump_fmat4x3
mat< 4, 3, f32, mediump > mediump_fmat4x3
Medium single-qualifier floating-point 4x3 matrix.
Definition: fwd.hpp:647

glm::mediump_f32mat3
mat< 3, 3, f32, mediump > mediump_f32mat3
Medium single-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:545

glm::mediump_uint32_t
uint32 mediump_uint32_t
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:127

glm::lowp_uint64
uint64 lowp_uint64
Low qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:136

glm::mediump_mat3x3
mat< 3, 3, float, mediump > mediump_mat3x3
3 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
Definition: matrix_float3x3_precision.hpp:40

glm::mediump_fmat2x2
mat< 2, 2, f32, mediump > mediump_fmat2x2
Medium single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:640

glm::f32vec1
vec< 1, f32, defaultp > f32vec1
Single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:461

glm::highp_f32mat4
mat< 4, 4, f32, highp > highp_f32mat4
High single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:550

glm::highp_quat
qua< float, highp > highp_quat
Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs...
Definition: quaternion_float_precision.hpp:32

glm::highp_float64
double highp_float64
High 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:170

glm::mediump_dmat3x2
mat< 3, 2, double, mediump > mediump_dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
Definition: matrix_double3x2_precision.hpp:22

glm::lowp_u8
uint8 lowp_u8
Low qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:89

glm::lowp_dmat3x2
mat< 3, 2, double, lowp > lowp_dmat3x2
3 columns of 2 components matrix of double-precision floating-point numbers using low precision arith...
Definition: matrix_double3x2_precision.hpp:16

glm::u32
uint32 u32
Default qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:120

glm::f64mat3
mat< 3, 3, f64, defaultp > f64mat3
Double-qualifier floating-point 3x3 matrix.
Definition: fwd.hpp:585

glm::highp_ivec2
vec< 2, int, highp > highp_ivec2
2 components vector of high qualifier signed integer numbers.
Definition: vector_int2_precision.hpp:16

glm::highp_dmat4x3
mat< 4, 3, double, highp > highp_dmat4x3
4 columns of 3 components matrix of double-precision floating-point numbers using medium precision ar...
Definition: matrix_double4x3_precision.hpp:28

glm::mediump_mat2x3
mat< 2, 3, float, mediump > mediump_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using medium precision ar...
Definition: matrix_float2x3_precision.hpp:22

glm::lowp_float64
double lowp_float64
Low 64 bit double-qualifier floating-point scalar.
Definition: fwd.hpp:168

glm::i32vec1
vec< 1, i32, defaultp > i32vec1
32 bit signed integer scalar type.
Definition: fwd.hpp:277

glm::highp_uint16
uint16 highp_uint16
High qualifier 16 bit unsigned integer type.
Definition: fwd.hpp:110

glm::mediump_f64mat2x4
mat< 2, 4, f64, mediump > mediump_f64mat2x4
Medium double-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:762

glm::highp_i64vec4
vec< 4, i64, highp > highp_i64vec4
High qualifier 64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:295

glm::mediump_dmat4x4
mat< 4, 4, double, mediump > mediump_dmat4x4
4 columns of 4 components matrix of double-precision floating-point numbers using medium precision ar...
Definition: matrix_double4x4_precision.hpp:40

glm::f64mat3x4
mat< 3, 4, f64, defaultp > f64mat3x4
Double-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:787

glm::highp_dvec4
vec< 4, double, highp > highp_dvec4
4 components vector of high double-qualifier floating-point numbers.
Definition: vector_double4_precision.hpp:18

glm::fmat2
mat< 2, 2, f32, defaultp > fmat2
Single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:536

glm::lowp_dmat3x4
mat< 3, 4, double, lowp > lowp_dmat3x4
3 columns of 4 components matrix of double-precision floating-point numbers using low precision arith...
Definition: matrix_double3x4_precision.hpp:16

glm::i16vec3
vec< 3, i16, defaultp > i16vec3
16 bit signed integer vector of 3 components type.
Definition: fwd.hpp:259

glm::lowp_uint32_t
uint32 lowp_uint32_t
Low qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:126

glm::lowp_fvec2
vec< 2, float, lowp > lowp_fvec2
Low single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:427

glm::mediump_uint32
uint32 mediump_uint32
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:123

glm::mediump_fmat4
mat< 4, 4, f32, mediump > mediump_fmat4
Medium single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:530

glm::highp_uint64
uint64 highp_uint64
High qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:138

glm::lowp_fmat2
mat< 2, 2, f32, lowp > lowp_fmat2
Low single-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:524

glm::lowp_uint32
uint32 lowp_uint32
Low qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:122

glm::lowp_fvec3
vec< 3, float, lowp > lowp_fvec3
Low single-qualifier floating-point vector of 3 components.
Definition: fwd.hpp:428

glm::mediump_fvec2
vec< 2, float, mediump > mediump_fvec2
Medium Single-qualifier floating-point vector of 2 components.
Definition: fwd.hpp:432

glm::highp_mat2x3
mat< 2, 3, float, highp > highp_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using high precision arit...
Definition: matrix_float2x3_precision.hpp:28

glm::lowp_fmat3x4
mat< 3, 4, f32, lowp > lowp_fmat3x4
Low single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:635

glm::vec2
vec< 2, float, defaultp > vec2
2 components vector of single-precision floating-point numbers.
Definition: vector_float2.hpp:15

glm::lowp_f64mat2x2
mat< 2, 2, f64, lowp > lowp_f64mat2x2
Low double-qualifier floating-point 1x1 matrix.
Definition: fwd.hpp:750

glm::i64vec4
vec< 4, i64, defaultp > i64vec4
64 bit signed integer vector of 4 components type.
Definition: fwd.hpp:300

glm::u16vec3
vec< 3, u16, defaultp > u16vec3
Default qualifier 16 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:361

glm::lowp_u64vec1
vec< 1, u64, lowp > lowp_u64vec1
Low qualifier 64 bit unsigned integer scalar type.
Definition: fwd.hpp:384

glm::mediump_dmat2
mat< 2, 2, double, mediump > mediump_dmat2
2 columns of 2 components matrix of double-precision floating-point numbers using medium precision ar...
Definition: matrix_double2x2_precision.hpp:22

glm::mediump_u16vec1
vec< 1, u16, mediump > mediump_u16vec1
Medium qualifier 16 bit unsigned integer scalar type.
Definition: fwd.hpp:349

glm::highp_vec2
vec< 2, float, highp > highp_vec2
2 components vector of high single-qualifier floating-point numbers.
Definition: vector_float2_precision.hpp:16

glm::i8vec2
vec< 2, i8, defaultp > i8vec2
8 bit signed integer vector of 2 components type.
Definition: fwd.hpp:238

glm::mediump_f64mat2x3
mat< 2, 3, f64, mediump > mediump_f64mat2x3
Medium double-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:761

glm::lowp_u32vec4
vec< 4, u32, lowp > lowp_u32vec4
Low qualifier 32 bit unsigned integer vector of 4 components type.
Definition: fwd.hpp:367

glm::highp_f32vec4
vec< 4, f32, highp > highp_f32vec4
High single-qualifier floating-point vector of 4 components.
Definition: fwd.hpp:459

glm::uvec3
vec< 3, unsigned int, defaultp > uvec3
3 components vector of unsigned integer numbers.
Definition: vector_uint3.hpp:15

glm::lowp_f32vec1
vec< 1, f32, lowp > lowp_f32vec1
Low single-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:446

glm::highp_f32mat2x3
mat< 2, 3, f32, highp > highp_f32mat2x3
High single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:691

glm::highp_int64
int64 highp_int64
High qualifier 64 bit signed integer type.
Definition: fwd.hpp:80

glm::mediump_i32vec2
vec< 2, i32, mediump > mediump_i32vec2
Medium qualifier 32 bit signed integer vector of 2 components type.
Definition: fwd.hpp:268

glm::lowp_dvec1
vec< 1, double, lowp > lowp_dvec1
1 component vector of double-precision floating-point numbers using low precision arithmetic in term ...
Definition: vector_double1_precision.hpp:33

glm::lowp_f64mat4
mat< 4, 4, f64, lowp > lowp_f64mat4
Low double-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:574

glm::fmat4
mat< 4, 4, f32, defaultp > fmat4
Single-qualifier floating-point 4x4 matrix.
Definition: fwd.hpp:538

glm::mediump_fmat3x4
mat< 3, 4, f32, mediump > mediump_fmat3x4
Medium single-qualifier floating-point 3x4 matrix.
Definition: fwd.hpp:645

glm::lowp_dmat3
mat< 3, 3, double, lowp > lowp_dmat3
3 columns of 3 components matrix of double-precision floating-point numbers using low precision arith...
Definition: matrix_double3x3_precision.hpp:16

glm::lowp_int16_t
int16 lowp_int16_t
Low qualifier 16 bit signed integer type.
Definition: fwd.hpp:54

glm::highp_i32vec4
vec< 4, i32, highp > highp_i32vec4
High qualifier 32 bit signed integer vector of 4 components type.
Definition: fwd.hpp:275

glm::f32mat4x2
mat< 4, 2, f32, defaultp > f32mat4x2
Single-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:702

glm::highp_fmat3x2
mat< 3, 2, f32, highp > highp_fmat3x2
High single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:653

glm::mat2x4
mat< 2, 4, float, defaultp > mat2x4
2 columns of 4 components matrix of single-precision floating-point numbers.
Definition: matrix_float2x4.hpp:15

glm::mediump_fmat2x3
mat< 2, 3, f32, mediump > mediump_fmat2x3
Medium single-qualifier floating-point 2x3 matrix.
Definition: fwd.hpp:641

glm::mediump_u32
uint32 mediump_u32
Medium qualifier 32 bit unsigned integer type.
Definition: fwd.hpp:118

glm::lowp_fmat3x2
mat< 3, 2, f32, lowp > lowp_fmat3x2
Low single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:633

glm::lowp_mat2x3
mat< 2, 3, float, lowp > lowp_mat2x3
2 columns of 3 components matrix of single-precision floating-point numbers using low precision arith...
Definition: matrix_float2x3_precision.hpp:16

glm::lowp_mat2
mat< 2, 2, float, lowp > lowp_mat2
2 columns of 2 components matrix of single-precision floating-point numbers using low precision arith...
Definition: matrix_float2x2_precision.hpp:16

glm::mediump_f64mat4x2
mat< 4, 2, f64, mediump > mediump_f64mat4x2
Medium double-qualifier floating-point 4x2 matrix.
Definition: fwd.hpp:766

glm::lowp_bvec4
vec< 4, bool, lowp > lowp_bvec4
4 components vector of low qualifier bool numbers.
Definition: vector_bool4_precision.hpp:28

glm::highp_u16vec2
vec< 2, u16, highp > highp_u16vec2
High qualifier 16 bit unsigned integer vector of 2 components type.
Definition: fwd.hpp:355

glm::highp_f64vec1
vec< 1, f64, highp > highp_f64vec1
High double-qualifier floating-point vector of 1 component.
Definition: fwd.hpp:496

glm::ivec3
vec< 3, int, defaultp > ivec3
3 components vector of signed integer numbers.
Definition: vector_int3.hpp:15

glm::mediump_i16vec2
vec< 2, i16, mediump > mediump_i16vec2
Medium qualifier 16 bit signed integer vector of 2 components type.
Definition: fwd.hpp:248

glm::highp_fmat2x4
mat< 2, 4, f32, highp > highp_fmat2x4
High single-qualifier floating-point 2x4 matrix.
Definition: fwd.hpp:652

glm::u64vec3
vec< 3, u64, defaultp > u64vec3
Default qualifier 64 bit unsigned integer vector of 3 components type.
Definition: fwd.hpp:401

glm::lowp_uint8
uint8 lowp_uint8
Low qualifier 8 bit unsigned integer type.
Definition: fwd.hpp:94

glm::lowp_f32mat3x2
mat< 3, 2, f32, lowp > lowp_f32mat3x2
Low single-qualifier floating-point 3x2 matrix.
Definition: fwd.hpp:673

glm::mediump_bvec4
vec< 4, bool, mediump > mediump_bvec4
4 components vector of medium qualifier bool numbers.
Definition: vector_bool4_precision.hpp:22

glm::mat3x2
mat< 3, 2, float, defaultp > mat3x2
3 columns of 2 components matrix of single-precision floating-point numbers.
Definition: matrix_float3x2.hpp:15

glm::lowp_u64
uint64 lowp_u64
Low qualifier 64 bit unsigned integer type.
Definition: fwd.hpp:131

glm::mediump_uvec1
vec< 1, unsigned int, mediump > mediump_uvec1
1 component vector of unsigned integer values.
Definition: vector_uint1_precision.hpp:32

glm::highp_i64vec3
vec< 3, i64, highp > highp_i64vec3
High qualifier 64 bit signed integer vector of 3 components type.
Definition: fwd.hpp:294

glm::mediump_int8
int8 mediump_int8
Medium qualifier 8 bit signed integer type.
Definition: fwd.hpp:37