GLM 0.9.6 Function Reference

GTC Extensions (Stable)

GLM_GTC_bitfield <glm/gtc/bitfield.hpp>
genIUType	bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)
vecType<T, P>	bitfieldFillOne(vecType<T, P> const &Value, int FirstBit, int BitCount)
genIUType	bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)
vecType<T, P>	bitfieldFillZero(vecType<T, P> const &Value, int FirstBit, int BitCount)
int16	bitfieldInterleave(int8 x, int8 y)
uint16	bitfieldInterleave(uint8 x, uint8 y)
int32	bitfieldInterleave(int16 x, int16 y)
uint32	bitfieldInterleave(uint16 x, uint16 y)
int64	bitfieldInterleave(int32 x, int32 y)
uint64	bitfieldInterleave(uint32 x, uint32 y)
int32	bitfieldInterleave(int8 x, int8 y, int8 z)
uint32	bitfieldInterleave(uint8 x, uint8 y, uint8 z)
int64	bitfieldInterleave(int16 x, int16 y, int16 z)
uint64	bitfieldInterleave(uint16 x, uint16 y, uint16 z)
int64	bitfieldInterleave(int32 x, int32 y, int32 z)
uint64	bitfieldInterleave(uint32 x, uint32 y, uint32 z)
int32	bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
uint32	bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
int64	bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
uint64	bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
genIUType	bitfieldRotateLeft(genIUType In, int Shift)
vecType<T, P>	bitfieldRotateLeft(vecType<T, P> const &In, int Shift)
genIUType	bitfieldRotateRight(genIUType In, int Shift)
vecType<T, P>	bitfieldRotateRight(vecType<T, P> const &In, int Shift)
genIUType	mask(genIUType Bits)
vecIUType<T, P>	mask(vecIUType<T, P> const &v)

GLM_GTC_constants <glm/gtc/constants.hpp>
genType	e()
genType	epsilon()
genType	euler()
genType	four_over_pi()
genType	golden_ratio()
genType	half_pi()
genType	ln_ln_two()
genType	ln_ten()
genType	ln_two()
genType	one()
genType	one_over_pi()
genType	one_over_root_two()
genType	one_over_two_pi()
genType	pi()
genType	quarter_pi()
genType	root_five()
genType	root_half_pi()
genType	root_ln_four()
genType	root_pi()
genType	root_three()
genType	root_two()
genType	root_two_pi()
genType	third()
genType	three_over_two_pi()
genType	two_over_pi()
genType	two_over_root_pi()
genType	two_pi()
genType	two_thirds()
genType	zero()

GLM_GTC_epsilon <glm/gtc/epsilon.hpp>
vecType<bool, P>	epsilonEqual(vecType<T, P> const &x, vecType<T, P> const &y, T const &epsilon)
bool	epsilonEqual(genType const &x, genType const &y, genType const &epsilon)
genType::boolType	epsilonNotEqual(genType const &x, genType const &y, genType::value_type const &epsilon)
bool	epsilonNotEqual(genType const &x, genType const &y, genType const &epsilon)

GLM_GTC_integer <glm/gtc/integer.hpp>
genIUType	log2(genIUType x)
genIUType	mod(genIUType x, genIUType y)
vecType<T, P>	mod(vecType<T, P> const &x, T y)
vecType<T, P>	mod(vecType<T, P> const &x, vecType<T, P> const &y)

GLM_GTC_matrix_access <glm/gtc/matrix_access.hpp>
genType::col_type	column(genType const &m, length_t index)
genType	column(genType const &m, length_t index, genType::col_type const &x)
genType::row_type	row(genType const &m, length_t index)
genType	row(genType const &m, length_t index, genType::row_type const &x)

GLM_GTC_matrix_inverse <glm/gtc/matrix_inverse.hpp>
genType	affineInverse(genType const &m)
genType	inverseTranspose(genType const &m)

GLM_GTC_matrix_transform <glm/gtc/matrix_transform.hpp>
tmat4x4<T, defaultp>	frustum(T left, T right, T bottom, T top, T near, T far)
tmat4x4<T, defaultp>	infinitePerspective(T fovy, T aspect, T near)
tmat4x4<T, P>	lookAt(tvec3<T, P> const &eye, tvec3<T, P> const &center, tvec3<T, P> const &up)
tmat4x4<T, defaultp>	ortho(T left, T right, T bottom, T top, T zNear, T zFar)
tmat4x4<T, defaultp>	ortho(T left, T right, T bottom, T top)
tmat4x4<T, defaultp>	perspective(T fovy, T aspect, T near, T far)
tmat4x4<T, defaultp>	perspectiveFov(T fov, T width, T height, T near, T far)
tmat4x4<T, P>	pickMatrix(tvec2<T, P> const &center, tvec2<T, P> const &delta, tvec4<U, P> const &viewport)
tvec3<T, P>	project(tvec3<T, P> const &obj, tmat4x4<T, P> const &model, tmat4x4<T, P> const &proj, tvec4<U, P> const &viewport)
tmat4x4<T, P>	rotate(tmat4x4<T, P> const &m, T angle, tvec3<T, P> const &axis)
tmat4x4<T, P>	scale(tmat4x4<T, P> const &m, tvec3<T, P> const &v)
tmat4x4<T, P>	translate(tmat4x4<T, P> const &m, tvec3<T, P> const &v)
tmat4x4<T, defaultp>	tweakedInfinitePerspective(T fovy, T aspect, T near)
tmat4x4<T, defaultp>	tweakedInfinitePerspective(T fovy, T aspect, T near, T ep)
tvec3<T, P>	unProject(tvec3<T, P> const &win, tmat4x4<T, P> const &model, tmat4x4<T, P> const &proj, tvec4<U, P> const &viewport)

GLM_GTC_noise <glm/gtc/noise.hpp>
T	perlin(vecType<T, P> const &p)
T	perlin(vecType<T, P> const &p, vecType<T, P> const &rep)
T	simplex(vecType<T, P> const &p)

GLM_GTC_packing <glm/gtc/packing.hpp>
uint32	packF2x11_1x10(vec3 const &v)
uint16	packHalf1x16(float v)
uint64	packHalf4x16(vec4 const &v)
uint32	packI3x10_1x2(ivec4 const &v)
uint16	packSnorm1x16(float v)
uint8	packSnorm1x8(float s)
uint16	packSnorm2x8(vec2 const &v)
uint32	packSnorm3x10_1x2(vec4 const &v)
uint64	packSnorm4x16(vec4 const &v)
uint32	packU3x10_1x2(uvec4 const &v)
uint16	packUnorm1x16(float v)
uint8	packUnorm1x8(float v)
uint16	packUnorm2x8(vec2 const &v)
uint32	packUnorm3x10_1x2(vec4 const &v)
uint64	packUnorm4x16(vec4 const &v)
vec3	unpackF2x11_1x10(uint32 p)
float	unpackHalf1x16(uint16 v)
vec4	unpackHalf4x16(uint64 p)
ivec4	unpackI3x10_1x2(uint32 p)
float	unpackSnorm1x16(uint16 p)
float	unpackSnorm1x8(uint8 p)
vec2	unpackSnorm2x8(uint16 p)
vec4	unpackSnorm3x10_1x2(uint32 p)
vec4	unpackSnorm4x16(uint64 const &p)
uvec4	unpackU3x10_1x2(uint32 p)
float	unpackUnorm1x16(uint16 p)
float	unpackUnorm1x8(uint8 p)
vec2	unpackUnorm2x8(uint16 p)
vec4	unpackUnorm3x10_1x2(uint32 p)
vec4	unpackUnorm4x16(uint64 p)

GLM_GTC_quaternion <glm/gtc/quaternion.hpp>
T	angle(tquat<T, P> const &x)
tquat<T, P>	angleAxis(T const &angle, tvec3<T, P> const &axis)
tvec3<T, P>	axis(tquat<T, P> const &x)
tquat<T, P>	conjugate(tquat<T, P> const &q)
T	dot(quatType<T, P> const &x, quatType<T, P> const &y)
tvec4<bool, P>	equal(tquat<T, P> const &x, tquat<T, P> const &y)
tvec3<T, P>	eulerAngles(tquat<T, P> const &x)
tvec4<bool, P>	greaterThan(tquat<T, P> const &x, tquat<T, P> const &y)
tvec4<bool, P>	greaterThanEqual(tquat<T, P> const &x, tquat<T, P> const &y)
tquat<T, P>	inverse(tquat<T, P> const &q)
T	length(tquat<T, P> const &q)
tquat<T, P>	lerp(tquat<T, P> const &x, tquat<T, P> const &y, T a)
tvec4<bool, P>	lessThan(tquat<T, P> const &x, tquat<T, P> const &y)
tvec4<bool, P>	lessThanEqual(tquat<T, P> const &x, tquat<T, P> const &y)
tmat3x3<T, P>	mat3_cast(tquat<T, P> const &x)
tmat4x4<T, P>	mat4_cast(tquat<T, P> const &x)
tquat<T, P>	mix(tquat<T, P> const &x, tquat<T, P> const &y, T a)
tquat<T, P>	normalize(tquat<T, P> const &q)
tvec4<bool, P>	notEqual(tquat<T, P> const &x, tquat<T, P> const &y)
T	pitch(tquat<T, P> const &x)
tquat<T, P>	quat_cast(tmat3x3<T, P> const &x)
tquat<T, P>	quat_cast(tmat4x4<T, P> const &x)
T	roll(tquat<T, P> const &x)
tquat<T, P>	rotate(tquat<T, P> const &q, T const &angle, tvec3<T, P> const &axis)
tquat<T, P>	slerp(tquat<T, P> const &x, tquat<T, P> const &y, T a)
T	yaw(tquat<T, P> const &x)

GLM_GTC_random <glm/gtc/random.hpp>
tvec3<T, defaultp>	ballRand(T Radius)
tvec2<T, defaultp>	circularRand(T Radius)
tvec2<T, defaultp>	diskRand(T Radius)
genType	gaussRand(genType Mean, genType Deviation)
genTYpe	linearRand(genTYpe Min, genTYpe Max)
tvec3<T, defaultp>	sphericalRand(T Radius)

GLM_GTC_reciprocal <glm/gtc/reciprocal.hpp>
genType	acot(genType const &x)
genType	acoth(genType const &x)
genType	acsc(genType const &x)
genType	acsch(genType const &x)
genType	asec(genType const &x)
genType	asech(genType const &x)
genType	cot(genType const &angle)
genType	coth(genType const &angle)
genType	csc(genType const &angle)
genType	csch(genType const &angle)
genType	sec(genType const &angle)
genType	sech(genType const &angle)

GLM_GTC_round <glm/gtc/round.hpp>
genType	ceilMultiple(genType Source, genType Multiple)
vecType<T, P>	ceilMultiple(vecType<T, P> const &Source, vecType<T, P> const &Multiple)
genIUType	ceilPowerOfTwo(genIUType Value)
vecType<T, P>	ceilPowerOfTwo(vecType<T, P> const &value)
genType	floorMultiple(genType Source, genType Multiple)
vecType<T, P>	floorMultiple(vecType<T, P> const &Source, vecType<T, P> const &Multiple)
genIUType	floorPowerOfTwo(genIUType Value)
vecType<T, P>	floorPowerOfTwo(vecType<T, P> const &value)
bool	isMultiple(genIUType Value, genIUType Multiple)
vecType<bool, P>	isMultiple(vecType<T, P> const &Value, T Multiple)
vecType<bool, P>	isMultiple(vecType<T, P> const &Value, vecType<T, P> const &Multiple)
bool	isPowerOfTwo(genIUType Value)
vecType<bool, P>	isPowerOfTwo(vecType<T, P> const &value)
genType	roundMultiple(genType Source, genType Multiple)
vecType<T, P>	roundMultiple(vecType<T, P> const &Source, vecType<T, P> const &Multiple)
genIUType	roundPowerOfTwo(genIUType Value)
vecType<T, P>	roundPowerOfTwo(vecType<T, P> const &value)

GLM_GTC_type_ptr <glm/gtc/type_ptr.hpp>
tmat2x2<T, defaultp>	make_mat2(T const *const ptr)
tmat2x2<T, defaultp>	make_mat2x2(T const *const ptr)
tmat2x3<T, defaultp>	make_mat2x3(T const *const ptr)
tmat2x4<T, defaultp>	make_mat2x4(T const *const ptr)
tmat3x3<T, defaultp>	make_mat3(T const *const ptr)
tmat3x2<T, defaultp>	make_mat3x2(T const *const ptr)
tmat3x3<T, defaultp>	make_mat3x3(T const *const ptr)
tmat3x4<T, defaultp>	make_mat3x4(T const *const ptr)
tmat4x4<T, defaultp>	make_mat4(T const *const ptr)
tmat4x2<T, defaultp>	make_mat4x2(T const *const ptr)
tmat4x3<T, defaultp>	make_mat4x3(T const *const ptr)
tmat4x4<T, defaultp>	make_mat4x4(T const *const ptr)
tquat<T, defaultp>	make_quat(T const *const ptr)
tvec2<T, defaultp>	make_vec2(T const *const ptr)
tvec3<T, defaultp>	make_vec3(T const *const ptr)
tvec4<T, defaultp>	make_vec4(T const *const ptr)
genType::value_type const*	value_ptr(genType const &vec)

GLM_GTC_ulp <glm/gtc/ulp.hpp>
uint	float_distance(T const &x, T const &y)
vecType<uint>	float_distance(vecType<T> const &x, vecType<T> const &y)
genType	next_float(genType const &x)
genType	next_float(genType const &x, uint const &Distance)
genType	prev_float(genType const &x)
genType	prev_float(genType const &x, uint const &Distance)

GTX Extensions (Experimental)

GLM_GTX_associated_min_max <glm/gtx/associated_min_max.hpp>
U	associatedMax(T x, U a, T y, U b)
tvec2<U, P>	associatedMax(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b)
vecType<T, P>	associatedMax(T x, vecType<U, P> const &a, T y, vecType<U, P> const &b)
vecType<U, P>	associatedMax(vecType<T, P> const &x, U a, vecType<T, P> const &y, U b)
U	associatedMax(T x, U a, T y, U b, T z, U c)
vecType<U, P>	associatedMax(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b, vecType<T, P> const &z, vecType<U, P> const &c)
vecType<T, P>	associatedMax(T x, vecType<U, P> const &a, T y, vecType<U, P> const &b, T z, vecType<U, P> const &c)
vecType<U, P>	associatedMax(vecType<T, P> const &x, U a, vecType<T, P> const &y, U b, vecType<T, P> const &z, U c)
U	associatedMax(T x, U a, T y, U b, T z, U c, T w, U d)
vecType<U, P>	associatedMax(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b, vecType<T, P> const &z, vecType<U, P> const &c, vecType<T, P> const &w, vecType<U, P> const &d)
vecType<U, P>	associatedMax(T x, vecType<U, P> const &a, T y, vecType<U, P> const &b, T z, vecType<U, P> const &c, T w, vecType<U, P> const &d)
vecType<U, P>	associatedMax(vecType<T, P> const &x, U a, vecType<T, P> const &y, U b, vecType<T, P> const &z, U c, vecType<T, P> const &w, U d)
U	associatedMin(T x, U a, T y, U b)
tvec2<U, P>	associatedMin(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b)
vecType<U, P>	associatedMin(T x, const vecType<U, P> &a, T y, const vecType<U, P> &b)
vecType<U, P>	associatedMin(vecType<T, P> const &x, U a, vecType<T, P> const &y, U b)
U	associatedMin(T x, U a, T y, U b, T z, U c)
vecType<U, P>	associatedMin(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b, vecType<T, P> const &z, vecType<U, P> const &c)
U	associatedMin(T x, U a, T y, U b, T z, U c, T w, U d)
vecType<U, P>	associatedMin(vecType<T, P> const &x, vecType<U, P> const &a, vecType<T, P> const &y, vecType<U, P> const &b, vecType<T, P> const &z, vecType<U, P> const &c, vecType<T, P> const &w, vecType<U, P> const &d)
vecType<U, P>	associatedMin(T x, vecType<U, P> const &a, T y, vecType<U, P> const &b, T z, vecType<U, P> const &c, T w, vecType<U, P> const &d)
vecType<U, P>	associatedMin(vecType<T, P> const &x, U a, vecType<T, P> const &y, U b, vecType<T, P> const &z, U c, vecType<T, P> const &w, U d)

GLM_GTX_bit <glm/gtx/bit.hpp>
genIUType	highestBitValue(genIUType Value)
vecType<T, P>	highestBitValue(vecType<T, P> const &value)
genIUType	powerOfTwoAbove(genIUType Value) [deprecated]
vecType<T, P>	powerOfTwoAbove(vecType<T, P> const &value) [deprecated]
genIUType	powerOfTwoBelow(genIUType Value) [deprecated]
vecType<T, P>	powerOfTwoBelow(vecType<T, P> const &value) [deprecated]
genIUType	powerOfTwoNearest(genIUType Value) [deprecated]
vecType<T, P>	powerOfTwoNearest(vecType<T, P> const &value) [deprecated]

GLM_GTX_closest_point <glm/gtx/closest_point.hpp>
tvec3<T, P>	closestPointOnLine(tvec3<T, P> const &point, tvec3<T, P> const &a, tvec3<T, P> const &b)
tvec2<T, P>	closestPointOnLine(tvec2<T, P> const &point, tvec2<T, P> const &a, tvec2<T, P> const &b)

GLM_GTX_color_space <glm/gtx/color_space.hpp>
tvec3<T, P>	hsvColor(tvec3<T, P> const &rgbValue)
T	luminosity(tvec3<T, P> const &color)
tvec3<T, P>	rgbColor(tvec3<T, P> const &hsvValue)
tmat4x4<T, defaultp>	saturation(T const s)
tvec3<T, P>	saturation(T const s, tvec3<T, P> const &color)
tvec4<T, P>	saturation(T const s, tvec4<T, P> const &color)

GLM_GTX_color_space_YCoCg <glm/gtx/color_space_YCoCg.hpp>
tvec3<T, P>	rgb2YCoCg(tvec3<T, P> const &rgbColor)
tvec3<T, P>	rgb2YCoCgR(tvec3<T, P> const &rgbColor)
tvec3<T, P>	YCoCg2rgb(tvec3<T, P> const &YCoCgColor)
tvec3<T, P>	YCoCgR2rgb(tvec3<T, P> const &YCoCgColor)

GLM_GTX_common <glm/gtx/common.hpp>
genType::bool_type	isdenormal(genType const &x)

GLM_GTX_compatibility <glm/gtx/compatibility.hpp>
T	atan2(T x, T y)
tvec2<T, P>	atan2(const tvec2<T, P> &x, const tvec2<T, P> &y)
tvec3<T, P>	atan2(const tvec3<T, P> &x, const tvec3<T, P> &y)
tvec4<T, P>	atan2(const tvec4<T, P> &x, const tvec4<T, P> &y)
bool	isfinite(genType const &x)
tvec2<bool, P>	isfinite(const tvec2<T, P> &x)
tvec3<bool, P>	isfinite(const tvec3<T, P> &x)
tvec4<bool, P>	isfinite(const tvec4<T, P> &x)
T	lerp(T x, T y, T a)
tvec2<T, P>	lerp(const tvec2<T, P> &x, const tvec2<T, P> &y, T a)
tvec3<T, P>	lerp(const tvec3<T, P> &x, const tvec3<T, P> &y, T a)
tvec4<T, P>	lerp(const tvec4<T, P> &x, const tvec4<T, P> &y, T a)
tvec2<T, P>	lerp(const tvec2<T, P> &x, const tvec2<T, P> &y, const tvec2<T, P> &a)
tvec3<T, P>	lerp(const tvec3<T, P> &x, const tvec3<T, P> &y, const tvec3<T, P> &a)
tvec4<T, P>	lerp(const tvec4<T, P> &x, const tvec4<T, P> &y, const tvec4<T, P> &a)
T	saturate(T x)
tvec2<T, P>	saturate(const tvec2<T, P> &x)
tvec3<T, P>	saturate(const tvec3<T, P> &x)
tvec4<T, P>	saturate(const tvec4<T, P> &x)

GLM_GTX_component_wise <glm/gtx/component_wise.hpp>
genType::value_type	compAdd(genType const &v)
genType::value_type	compMax(genType const &v)
genType::value_type	compMin(genType const &v)
genType::value_type	compMul(genType const &v)

GLM_GTX_dual_quaternion <glm/gtx/dual_quaternion.hpp>
tdualquat<T, P>	dualquat_cast(tmat2x4<T, P> const &x)
tdualquat<T, P>	dualquat_cast(tmat3x4<T, P> const &x)
tdualquat<T, P>	inverse(tdualquat<T, P> const &q)
tdualquat<T, P>	lerp(tdualquat<T, P> const &x, tdualquat<T, P> const &y, T const &a)
tmat2x4<T, P>	mat2x4_cast(tdualquat<T, P> const &x)
tmat3x4<T, P>	mat3x4_cast(tdualquat<T, P> const &x)
tdualquat<T, P>	normalize(tdualquat<T, P> const &q)

GLM_GTX_euler_angles <glm/gtx/euler_angles.hpp>
tmat4x4<T, defaultp>	eulerAngleX(T const &angleX)
tmat4x4<T, defaultp>	eulerAngleXY(T const &angleX, T const &angleY)
tmat4x4<T, defaultp>	eulerAngleXZ(T const &angleX, T const &angleZ)
tmat4x4<T, defaultp>	eulerAngleY(T const &angleY)
tmat4x4<T, defaultp>	eulerAngleYX(T const &angleY, T const &angleX)
tmat4x4<T, defaultp>	eulerAngleYXZ(T const &yaw, T const &pitch, T const &roll)
tmat4x4<T, defaultp>	eulerAngleYZ(T const &angleY, T const &angleZ)
tmat4x4<T, defaultp>	eulerAngleZ(T const &angleZ)
tmat4x4<T, defaultp>	eulerAngleZX(T const &angle, T const &angleX)
tmat4x4<T, defaultp>	eulerAngleZY(T const &angleZ, T const &angleY)
tmat2x2<T, defaultp>	orientate2(T const &angle)
tmat3x3<T, defaultp>	orientate3(T const &angle)
tmat3x3<T, P>	orientate3(tvec3<T, P> const &angles)
tmat4x4<T, P>	orientate4(tvec3<T, P> const &angles)
tmat4x4<T, defaultp>	yawPitchRoll(T const &yaw, T const &pitch, T const &roll)

GLM_GTX_extend <glm/gtx/extend.hpp>
genType	extend(genType const &Origin, genType const &Source, genType::value_type const Length)

GLM_GTX_extented_min_max <glm/gtx/extented_min_max.hpp>
T	max(T const &x, T const &y, T const &z)
C<T>	max(C<T> const &x, C<T>::T const &y, C<T>::T const &z)
C<T>	max(C<T> const &x, C<T> const &y, C<T> const &z)
T	max(T const &x, T const &y, T const &z, T const &w)
C<T>	max(C<T> const &x, C<T>::T const &y, C<T>::T const &z, C<T>::T const &w)
C<T>	max(C<T> const &x, C<T> const &y, C<T> const &z, C<T> const &w)
T	min(T const &x, T const &y, T const &z)
C<T>	min(C<T> const &x, C<T>::T const &y, C<T>::T const &z)
C<T>	min(C<T> const &x, C<T> const &y, C<T> const &z)
T	min(T const &x, T const &y, T const &z, T const &w)
C<T>	min(C<T> const &x, C<T>::T const &y, C<T>::T const &z, C<T>::T const &w)
C<T>	min(C<T> const &x, C<T> const &y, C<T> const &z, C<T> const &w)

GLM_GTX_fast_exponential <glm/gtx/fast_exponential.hpp>
T	fastExp(T x)
vecType<T, P>	fastExp(vecType<T, P> const &x)
T	fastExp2(T x)
vecType<T, P>	fastExp2(vecType<T, P> const &x)
T	fastLog(T x)
vecType<T, P>	fastLog(vecType<T, P> const &x)
T	fastLog2(T x)
vecType<T, P>	fastLog2(vecType<T, P> const &x)
genType	fastPow(genType x, genType y)
vecType<T, P>	fastPow(vecType<T, P> const &x, vecType<T, P> const &y)
genTypeT	fastPow(genTypeT x, genTypeU y)
vecType<T, P>	fastPow(vecType<T, P> const &x)

GLM_GTX_fast_square_root <glm/gtx/fast_square_root.hpp>
genType	fastDistance(genType x, genType y)
T	fastDistance(vecType<T, P> const &x, vecType<T, P> const &y)
genType	fastInverseSqrt(genType x)
vecType<T, P>	fastInverseSqrt(vecType<T, P> const &x)
genType	fastLength(genType x)
T	fastLength(vecType<T, P> const &x)
genType	fastNormalize(genType const &x)
genType	fastSqrt(genType x)
vecType<T, P>	fastSqrt(vecType<T, P> const &x)

GLM_GTX_fast_trigonometry <glm/gtx/fast_trigonometry.hpp>
T	fastAcos(T angle)
T	fastAsin(T angle)
T	fastAtan(T y, T x)
T	fastAtan(T angle)
T	fastCos(T angle)
T	fastSin(T angle)
T	fastTan(T angle)
T	wrapAngle(T angle)

GLM_GTX_gradient_paint <glm/gtx/gradient_paint.hpp>
T	linearGradient(tvec2<T, P> const &Point0, tvec2<T, P> const &Point1, tvec2<T, P> const &Position)
T	radialGradient(tvec2<T, P> const &Center, T const &Radius, tvec2<T, P> const &Focal, tvec2<T, P> const &Position)

GLM_GTX_handed_coordinate_space <glm/gtx/handed_coordinate_system.hpp>
bool	leftHanded(tvec3<T, P> const &tangent, tvec3<T, P> const &binormal, tvec3<T, P> const &normal)
bool	rightHanded(tvec3<T, P> const &tangent, tvec3<T, P> const &binormal, tvec3<T, P> const &normal)

GLM_GTX_integer <glm/gtx/integer.hpp>
genType	factorial(genType const &x)
unsigned int	floor_log2(unsigned int x)
int	mod(int x, int y)
uint	mod(uint x, uint y)
uint	nlz(uint x)
int	pow(int x, int y)
uint	pow(uint x, uint y)
int	sqrt(int x)
uint	sqrt(uint x)

GLM_GTX_intersect <glm/gtx/intersect.hpp>
bool	intersectLineSphere(genType const &point0, genType const &point1, genType const &sphereCenter, genType::value_type sphereRadius, genType &intersectionPosition1, genType &intersectionNormal1, genType &intersectionPosition2=genType(), genType &intersectionNormal2=genType())
bool	intersectLineTriangle(genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &position)
bool	intersectRayPlane(genType const &orig, genType const &dir, genType const &planeOrig, genType const &planeNormal, genType::value_type &intersectionDistance)
bool	intersectRaySphere(genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, genType::value_type const sphereRadiusSquered, genType::value_type &intersectionDistance)
bool	intersectRaySphere(genType const &rayStarting, genType const &rayNormalizedDirection, genType const &sphereCenter, const genType::value_type sphereRadius, genType &intersectionPosition, genType &intersectionNormal)
bool	intersectRayTriangle(genType const &orig, genType const &dir, genType const &vert0, genType const &vert1, genType const &vert2, genType &baryPosition)

GLM_GTX_log_base <glm/gtx/log_base.hpp>
genType	log(genType x, genType base)
vecType<T, P>	sign(vecType<T, P> const &x, vecType<T, P> const &base)

GLM_GTX_matrix_cross_product <glm/gtx/matrix_cross_product.hpp>
tmat3x3<T, P>	matrixCross3(tvec3<T, P> const &x)
tmat4x4<T, P>	matrixCross4(tvec3<T, P> const &x)

GLM_GTX_matrix_decompose <glm/gtx/decomposition.hpp>
bool	decompose(tmat4x4<T, P> const &modelMatrix, tvec3<T, P> &scale, tquat<T, P> &orientation, tvec3<T, P> &translation, tvec3<T, P> &skew, tvec4<T, P> &perspective)

GLM_GTX_matrix_interpolation <glm/gtx/matrix_interpolation.hpp>
void	axisAngle(tmat4x4<T, P> const &mat, tvec3<T, P> &axis, T &angle)
tmat4x4<T, P>	axisAngleMatrix(tvec3<T, P> const &axis, T const angle)
tmat4x4<T, P>	extractMatrixRotation(tmat4x4<T, P> const &mat)
tmat4x4<T, P>	interpolate(tmat4x4<T, P> const &m1, tmat4x4<T, P> const &m2, T const delta)

GLM_GTX_matrix_major_storage <glm/gtx/matrix_major_storage.hpp>
tmat2x2<T, P>	colMajor2(tvec2<T, P> const &v1, tvec2<T, P> const &v2)
tmat2x2<T, P>	colMajor2(tmat2x2<T, P> const &m)
tmat3x3<T, P>	colMajor3(tvec3<T, P> const &v1, tvec3<T, P> const &v2, tvec3<T, P> const &v3)
tmat3x3<T, P>	colMajor3(tmat3x3<T, P> const &m)
tmat4x4<T, P>	colMajor4(tvec4<T, P> const &v1, tvec4<T, P> const &v2, tvec4<T, P> const &v3, tvec4<T, P> const &v4)
tmat4x4<T, P>	colMajor4(tmat4x4<T, P> const &m)
tmat2x2<T, P>	rowMajor2(tvec2<T, P> const &v1, tvec2<T, P> const &v2)
tmat2x2<T, P>	rowMajor2(tmat2x2<T, P> const &m)
tmat3x3<T, P>	rowMajor3(tvec3<T, P> const &v1, tvec3<T, P> const &v2, tvec3<T, P> const &v3)
tmat3x3<T, P>	rowMajor3(tmat3x3<T, P> const &m)
tmat4x4<T, P>	rowMajor4(tvec4<T, P> const &v1, tvec4<T, P> const &v2, tvec4<T, P> const &v3, tvec4<T, P> const &v4)
tmat4x4<T, P>	rowMajor4(tmat4x4<T, P> const &m)

GLM_GTX_matrix_operation <glm/gtx/matrix_operation.hpp>
tmat2x2<T, P>	diagonal2x2(tvec2<T, P> const &v)
tmat2x3<T, P>	diagonal2x3(tvec2<T, P> const &v)
tmat2x4<T, P>	diagonal2x4(tvec2<T, P> const &v)
tmat3x2<T, P>	diagonal3x2(tvec2<T, P> const &v)
tmat3x3<T, P>	diagonal3x3(tvec3<T, P> const &v)
tmat3x4<T, P>	diagonal3x4(tvec3<T, P> const &v)
tmat4x2<T, P>	diagonal4x2(tvec2<T, P> const &v)
tmat4x3<T, P>	diagonal4x3(tvec3<T, P> const &v)
tmat4x4<T, P>	diagonal4x4(tvec4<T, P> const &v)

GLM_GTX_matrix_query <glm/gtx/matrix_query.hpp>
bool	isIdentity(matType<T, P> const &m, T const &epsilon)
bool	isNormalized(tmat2x2<T, P> const &m, T const &epsilon)
bool	isNormalized(tmat3x3<T, P> const &m, T const &epsilon)
bool	isNormalized(tmat4x4<T, P> const &m, T const &epsilon)
bool	isNull(tmat2x2<T, P> const &m, T const &epsilon)
bool	isNull(tmat3x3<T, P> const &m, T const &epsilon)
bool	isNull(tmat4x4<T, P> const &m, T const &epsilon)
bool	isOrthogonal(matType<T, P> const &m, T const &epsilon)

GLM_GTX_matrix_transform_2d <glm/gtx/matrix_transform_2d.hpp>
tmat3x3<T, P>	rotate(tmat3x3<T, P> const &m, T angle)
tmat3x3<T, P>	scale(tmat3x3<T, P> const &m, tvec2<T, P> const &v)
tmat3x3<T, P>	shearX(tmat3x3<T, P> const &m, T y)
tmat3x3<T, P>	shearY(tmat3x3<T, P> const &m, T x)
tmat3x3<T, P>	translate(tmat3x3<T, P> const &m, tvec2<T, P> const &v)

GLM_GTX_mixed_producte <glm/gtx/mixed_product.hpp>
T	mixedProduct(tvec3<T, P> const &v1, tvec3<T, P> const &v2, tvec3<T, P> const &v3)

GLM_GTX_multiple <glm/gtx/multiple.hpp>
genType	higherMultiple(genType Source, genType Multiple) [deprecated]
vecType<T, P>	higherMultiple(vecType<T, P> const &Source, vecType<T, P> const &Multiple) [deprecated]
genType	lowerMultiple(genType Source, genType Multiple) [deprecated]
vecType<T, P>	lowerMultiple(vecType<T, P> const &Source, vecType<T, P> const &Multiple) [deprecated]

GLM_GTX_norm <glm/gtx/norm.hpp>
T	distance2(T const &p0, T const &p1)
genType::value_type	distance2(genType const &p0, genType const &p1)
T	l1Norm(tvec3<T, P> const &x, tvec3<T, P> const &y)
T	l1Norm(tvec3<T, P> const &v)
T	l2Norm(tvec3<T, P> const &x, tvec3<T, P> const &y)
T	l2Norm(tvec3<T, P> const &x)
T	length2(T const &x)
genType::value_type	length2(genType const &x)
T	lxNorm(tvec3<T, P> const &x, tvec3<T, P> const &y, unsigned int Depth)
T	lxNorm(tvec3<T, P> const &x, unsigned int Depth)

GLM_GTX_normal <glm/gtx/normal.hpp>
tvec3<T, P>	triangleNormal(tvec3<T, P> const &p1, tvec3<T, P> const &p2, tvec3<T, P> const &p3)

GLM_GTX_normalize_dot <glm/gtx/normalized_dot.hpp>
T	fastNormalizeDot(vecType<T, P> const &x, vecType<T, P> const &y)
T	normalizeDot(vecType<T, P> const &x, vecType<T, P> const &y)

GLM_GTX_optimum_pow <glm/gtx/optimum_pow.hpp>
genType	pow2(genType const &x)
genType	pow3(genType const &x)
genType	pow4(genType const &x)

GLM_GTX_orthonormalize <glm/gtx/orthonormalize.hpp>
tmat3x3<T, P>	orthonormalize(tmat3x3<T, P> const &m)
tvec3<T, P>	orthonormalize(tvec3<T, P> const &x, tvec3<T, P> const &y)

GLM_GTX_perpendicular <glm/gtx/perpendicular.hpp>
vecType	perp(vecType const &x, vecType const &Normal)

GLM_GTX_polar_coordinates <glm/gtx/polar_coordinates.hpp>
tvec3<T, P>	euclidean(tvec2<T, P> const &polar)
tvec3<T, P>	polar(tvec3<T, P> const &euclidean)

GLM_GTX_projection <glm/gtx/projection.hpp>
vecType	proj(vecType const &x, vecType const &Normal)

GLM_GTX_quaternion <glm/gtx/quaternion.hpp>
tvec3<T, P>	cross(tquat<T, P> const &q, tvec3<T, P> const &v)
tvec3<T, P>	cross(tvec3<T, P> const &v, tquat<T, P> const &q)
tquat<T, P>	exp(tquat<T, P> const &q)
T	extractRealComponent(tquat<T, P> const &q)
tquat<T, P>	fastMix(tquat<T, P> const &x, tquat<T, P> const &y, T const &a)
tquat<T, P>	intermediate(tquat<T, P> const &prev, tquat<T, P> const &curr, tquat<T, P> const &next)
T	length2(tquat<T, P> const &q)
tquat<T, P>	log(tquat<T, P> const &q)
tquat<T, P>	pow(tquat<T, P> const &x, T const &y)
tvec3<T, P>	rotate(tquat<T, P> const &q, tvec3<T, P> const &v)
tvec4<T, P>	rotate(tquat<T, P> const &q, tvec4<T, P> const &v)
tquat<T, P>	rotation(tvec3<T, P> const &orig, tvec3<T, P> const &dest)
tquat<T, P>	shortMix(tquat<T, P> const &x, tquat<T, P> const &y, T const &a)
tquat<T, P>	squad(tquat<T, P> const &q1, tquat<T, P> const &q2, tquat<T, P> const &s1, tquat<T, P> const &s2, T const &h)
tmat3x3<T, P>	toMat3(tquat<T, P> const &x)
tmat4x4<T, P>	toMat4(tquat<T, P> const &x)
tquat<T, P>	toQuat(tmat3x3<T, P> const &x)
tquat<T, P>	toQuat(tmat4x4<T, P> const &x)

GLM_GTX_rotate_normalized_axis <glm/gtx/rotate_normalized_axis.hpp>
tmat4x4<T, P>	rotateNormalizedAxis(tmat4x4<T, P> const &m, T const &angle, tvec3<T, P> const &axis)
tquat<T, P>	rotateNormalizedAxis(tquat<T, P> const &q, T const &angle, tvec3<T, P> const &axis)

GLM_GTX_rotate_vector <glm/gtx/rotate_vector.hpp>
tmat4x4<T, P>	orientation(tvec3<T, P> const &Normal, tvec3<T, P> const &Up)
tvec2<T, P>	rotate(tvec2<T, P> const &v, T const &angle)
tvec3<T, P>	rotate(tvec3<T, P> const &v, T const &angle, tvec3<T, P> const &normal)
tvec4<T, P>	rotate(tvec4<T, P> const &v, T const &angle, tvec3<T, P> const &normal)
tvec3<T, P>	rotateX(tvec3<T, P> const &v, T const &angle)
tvec4<T, P>	rotateX(tvec4<T, P> const &v, T const &angle)
tvec3<T, P>	rotateY(tvec3<T, P> const &v, T const &angle)
tvec4<T, P>	rotateY(tvec4<T, P> const &v, T const &angle)
tvec3<T, P>	rotateZ(tvec3<T, P> const &v, T const &angle)
tvec4<T, P>	rotateZ(tvec4<T, P> const &v, T const &angle)
tvec3<T, P>	slerp(tvec3<T, P> const &x, tvec3<T, P> const &y, T const &a)

GLM_GTX_spline <glm/gtx/spline.hpp>
genType	catmullRom(genType const &v1, genType const &v2, genType const &v3, genType const &v4, genType::value_type const &s)
genType	cubic(genType const &v1, genType const &v2, genType const &v3, genType const &v4, genType::value_type const &s)
genType	hermite(genType const &v1, genType const &t1, genType const &v2, genType const &t2, genType::value_type const &s)

GLM_GTX_string_cast <glm/gtx/string_cast.hpp>
std::string	to_string(matType<T, P> const &x)

GLM_GTX_transform <glm/gtx/transform.hpp>
tmat4x4<T, P>	rotate(T angle, tvec3<T, P> const &v)
tmat4x4<T, P>	scale(tvec3<T, P> const &v)
tmat4x4<T, P>	translate(tvec3<T, P> const &v)

GLM_GTX_transform2 <glm/gtx/transform2.hpp>
tmat3x3<T, P>	proj2D(const tmat3x3<T, P> &m, const tvec3<T, P> &normal)
tmat4x4<T, P>	proj3D(const tmat4x4<T, P> &m, const tvec3<T, P> &normal)
tmat4x4<valType, P>	scaleBias(valType scale, valType bias)
tmat4x4<valType, P>	scaleBias(tmat4x4<valType, P> const &m, valType scale, valType bias)
tmat3x3<T, P>	shearX2D(tmat3x3<T, P> const &m, T y)
tmat4x4<T, P>	shearX3D(const tmat4x4<T, P> &m, T y, T z)
tmat3x3<T, P>	shearY2D(tmat3x3<T, P> const &m, T x)
tmat4x4<T, P>	shearY3D(const tmat4x4<T, P> &m, T x, T z)
tmat4x4<T, P>	shearZ3D(const tmat4x4<T, P> &m, T x, T y)

GLM_GTX_type_aligned <glm/gtx/type_aligned.hpp>
	GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1)
	GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2)
	GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4)
	GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8)
	GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1)
	GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2)
	GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4)
	GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8)
	GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1)
	GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2)
	GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4)
	GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8)
	GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1)
	GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2)
	GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4)
	GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8)
	GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1)
	GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2)
	GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4)
	GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8)
	GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1)
	GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2)
	GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4)
	GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8)
	GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1)
	GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2)
	GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4)
	GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8)
	GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1)
	GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2)
	GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4)
	GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8)
	GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1)
	GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2)
	GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4)
	GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8)
	GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1)
	GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2)
	GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4)
	GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8)
	GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1)
	GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2)
	GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4)
	GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8)
	GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1)
	GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2)
	GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4)
	GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8)
	GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4)
	GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8)
	GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16)
	GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16)
	GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1)
	GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2)
	GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4)
	GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4)
	GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2)
	GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4)
	GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8)
	GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8)
	GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4)
	GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8)
	GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16)
	GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16)
	GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8)
	GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16)
	GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32)
	GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32)
	GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1)
	GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2)
	GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4)
	GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8)
	GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1)
	GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2)
	GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4)
	GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8)
	GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1)
	GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2)
	GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4)
	GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8)
	GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1)
	GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2)
	GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4)
	GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8)
	GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1)
	GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2)
	GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4)
	GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8)
	GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1)
	GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2)
	GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4)
	GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8)
	GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1)
	GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2)
	GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4)
	GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8)
	GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1)
	GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2)
	GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4)
	GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8)
	GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1)
	GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2)
	GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4)
	GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8)
	GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1)
	GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2)
	GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4)
	GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8)
	GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1)
	GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2)
	GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4)
	GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8)
	GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1)
	GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2)
	GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4)
	GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8)
	GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4)
	GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8)
	GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16)
	GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16)
	GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1)
	GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2)
	GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4)
	GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4)
	GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2)
	GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4)
	GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8)
	GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8)
	GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4)
	GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8)
	GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16)
	GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16)
	GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8)
	GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16)
	GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32)
	GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32)
	GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4)
	GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8)
	GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4)
	GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8)
	GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4)
	GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8)
	GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4)
	GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8)
	GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16)
	GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16)
	GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4)
	GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8)
	GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16)
	GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16)
	GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4)
	GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8)
	GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16)
	GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16)
	GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8)
	GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16)
	GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32)
	GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32)
	GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8)
	GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16)
	GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32)
	GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32)
	GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16)
	GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16)
	GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16)
	GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16)
	GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16)
	GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16)
	GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16)
	GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16)
	GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16)
	GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16)
	GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16)
	GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16)
	GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16)
	GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16)
	GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16)
	GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16)
	GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16)
	GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16)
	GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16)
	GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16)
	GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16)
	GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16)
	GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16)
	GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16)
	GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16)
	GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16)
	GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16)
	GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16)
	GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16)
	GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16)
	GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32)
	GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32)
	GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32)
	GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32)
	GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32)
	GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32)
	GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32)
	GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32)
	GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32)
	GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32)
	GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32)
	GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32)
	GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16)
	GLM_ALIGNED_TYPEDEF(fquat, aligned_fquat, 16)
	GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32)
	GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16)
	GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32)

GLM_GTX_vector_angle <glm/gtx/vector_angle.hpp>
vecType::value_type	angle(vecType const &x, vecType const &y)
T	orientedAngle(tvec2<T, P> const &x, tvec2<T, P> const &y)
T	orientedAngle(tvec3<T, P> const &x, tvec3<T, P> const &y, tvec3<T, P> const &ref)

GLM_GTX_vector_query <glm/gtx/vector_query.hpp>
bool	areCollinear(vecType<T, P> const &v0, vecType<T, P> const &v1, T const &epsilon)
bool	areOrthogonal(vecType<T, P> const &v0, vecType<T, P> const &v1, T const &epsilon)
bool	areOrthonormal(vecType<T, P> const &v0, vecType<T, P> const &v1, T const &epsilon)
vecType<bool, P>	isCompNull(vecType<T, P> const &v, T const &epsilon)
bool	isNormalized(vecType<T, P> const &v, T const &epsilon)
bool	isNull(vecType<T, P> const &v, T const &epsilon)

GLM_GTX_wrap <glm/gtx/wrap.hpp>
genType	clamp(genType const &Texcoord)
genType	mirrorRepeat(genType const &Texcoord)
genType	repeat(genType const &Texcoord)

GLM Core

Common functions <glm/glm.hpp>
genType	abs(genType x)
vecType<T, P>	ceil(vecType<T, P> const &x)
genType	clamp(genType x, genType minVal, genType maxVal)
int	floatBitsToInt(float const &v)
vecType<int, P>	floatBitsToInt(vecType<float, P> const &v)
uint	floatBitsToUint(float const &v)
vecType<uint, P>	floatBitsToUint(vecType<float, P> const &v)
vecType<T, P>	floor(vecType<T, P> const &x)
genType	fma(genType const &a, genType const &b, genType const &c)
genType	fract(genType x)
genType	frexp(genType const &x, genIType &exp)
float	intBitsToFloat(int const &v)
vecType<float, P>	intBitsToFloat(vecType<int, P> const &v)
vecType<bool, P>	isinf(vecType<T, P> const &x)
vecType<bool, P>	isnan(vecType<T, P> const &x)
genType	ldexp(genType const &x, genIType const &exp)
genType	max(genType x, genType y)
genType	min(genType x, genType y)
vecType<T, P>	mix(vecType<T, P> const &x, vecType<T, P> const &y, vecType<U, P> const &a)
genType	mod(genType x, genType y)
genType	modf(genType x, genType &i)
vecType<T, P>	round(vecType<T, P> const &x)
vecType<T, P>	roundEven(vecType<T, P> const &x)
vecType<T, P>	sign(vecType<T, P> const &x)
genType	smoothstep(genType edge0, genType edge1, genType x)
genType	step(genType edge, genType x)
vecType<T, P>	step(T edge, vecType<T, P> const &x)
vecType<T, P>	step(vecType<T, P> const &edge, vecType<T, P> const &x)
vecType<T, P>	trunc(vecType<T, P> const &x)
float	uintBitsToFloat(uint const &v)
vecType<float, P>	uintBitsToFloat(vecType<uint, P> const &v)

Exponential functions <glm/glm.hpp>
vecType<T, P>	exp(vecType<T, P> const &v)
vecType<T, P>	exp2(vecType<T, P> const &v)
vecType<T, P>	inversesqrt(vecType<T, P> const &v)
vecType<T, P>	log(vecType<T, P> const &v)
vecType<T, P>	log2(vecType<T, P> const &v)
vecType<T, P>	pow(vecType<T, P> const &base, vecType<T, P> const &exponent)
vecType<T, P>	sqrt(vecType<T, P> const &v)

Geometric functions <glm/glm.hpp>
tvec3<T, P>	cross(tvec3<T, P> const &x, tvec3<T, P> const &y)
T	distance(vecType<T, P> const &p0, vecType<T, P> const &p1)
T	dot(vecType<T, P> const &x, vecType<T, P> const &y)
genType	faceforward(genType const &N, genType const &I, genType const &Nref)
T	length(vecType<T, P> const &x)
vecType<T, P>	normalize(vecType<T, P> const &x)
genType	reflect(genType const &I, genType const &N)
vecType<T, P>	refract(vecType<T, P> const &I, vecType<T, P> const &N, T eta)

Integer functions <glm/glm.hpp>
int	bitCount(genType v)
vecType<int, P>	bitCount(vecType<T, P> const &v)
vecType<T, P>	bitfieldExtract(vecType<T, P> const &Value, int Offset, int Bits)
vecType<T, P>	bitfieldInsert(vecType<T, P> const &Base, vecType<T, P> const &Insert, int Offset, int Bits)
vecType<T, P>	bitfieldReverse(vecType<T, P> const &v)
int	findLSB(genIUType x)
vecType<int, P>	findLSB(vecType<T, P> const &v)
int	findMSB(genIUType x)
vecType<int, P>	findMSB(vecType<T, P> const &v)
void	imulExtended(vecType<int, P> const &x, vecType<int, P> const &y, vecType<int, P> &msb, vecType<int, P> &lsb)
vecType<uint, P>	uaddCarry(vecType<uint, P> const &x, vecType<uint, P> const &y, vecType<uint, P> &carry)
void	umulExtended(vecType<uint, P> const &x, vecType<uint, P> const &y, vecType<uint, P> &msb, vecType<uint, P> &lsb)
vecType<uint, P>	usubBorrow(vecType<uint, P> const &x, vecType<uint, P> const &y, vecType<uint, P> &borrow)

Matrix functions <glm/glm.hpp>
T	determinant(matType<T, P> const &m)
matType<T, P>	inverse(matType<T, P> const &m)
matType<T, P>	matrixCompMult(matType<T, P> const &x, matType<T, P> const &y)
outerProduct_trait<T, P, vecTypeA, vecTypeB>::type	outerProduct(vecTypeA<T, P> const &c, vecTypeB<T, P> const &r)

Noise functions <glm/glm.hpp>
genType::value_type	noise1(genType const &x)
tvec2<genType::value_type, defaultp>	noise2(genType const &x)
tvec3<genType::value_type, defaultp>	noise3(genType const &x)
tvec4<genType::value_type, defaultp>	noise4(genType const &x)

Floating-Point Pack and Unpack Functions <glm/glm.hpp>
double	packDouble2x32(uvec2 const &v)
uint	packHalf2x16(vec2 const &v)
uint	packSnorm2x16(vec2 const &v)
uint	packSnorm4x8(vec4 const &v)
uint	packUnorm2x16(vec2 const &v)
uint	packUnorm4x8(vec4 const &v)
uvec2	unpackDouble2x32(double const &v)
vec2	unpackHalf2x16(uint const &v)
vec2	unpackSnorm2x16(uint const &p)
vec4	unpackSnorm4x8(uint const &p)
vec2	unpackUnorm2x16(uint const &p)
vec4	unpackUnorm4x8(uint const &p)

Angle and Trigonometry Functions <glm/glm.hpp>
vecType<T, P>	acos(vecType<T, P> const &x)
vecType<T, P>	acosh(vecType<T, P> const &x)
vecType<T, P>	asin(vecType<T, P> const &x)
vecType<T, P>	asinh(vecType<T, P> const &x)
vecType<T, P>	atan(vecType<T, P> const &y, vecType<T, P> const &x)
vecType<T, P>	atan(vecType<T, P> const &y_over_x)
vecType<T, P>	atanh(vecType<T, P> const &x)
vecType<T, P>	cos(vecType<T, P> const &angle)
vecType<T, P>	cosh(vecType<T, P> const &angle)
vecType<T, P>	degrees(vecType<T, P> const &radians)
vecType<T, P>	radians(vecType<T, P> const &degrees)
vecType<T, P>	sin(vecType<T, P> const &angle)
vecType<T, P>	sinh(vecType<T, P> const &angle)
vecType<T, P>	tan(vecType<T, P> const &angle)
vecType<T, P>	tanh(vecType<T, P> const &angle)

Vector Relational Functions <glm/glm.hpp>
bool	all(vecType<bool, P> const &v)
bool	any(vecType<bool, P> const &v)
vecType<bool, P>	equal(vecType<T, P> const &x, vecType<T, P> const &y)
vecType<bool, P>	greaterThan(vecType<T, P> const &x, vecType<T, P> const &y)
vecType<bool, P>	greaterThanEqual(vecType<T, P> const &x, vecType<T, P> const &y)
vecType<bool, P>	lessThan(vecType<T, P> const &x, vecType<T, P> const &y)
vecType<bool, P>	lessThanEqual(vecType<T, P> const &x, vecType<T, P> const &y)
vecType<bool, P>	not_(vecType<bool, P> const &v)
vecType<bool, P>	notEqual(vecType<T, P> const &x, vecType<T, P> const &y)