mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-16 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add GLM_NOEXCEPT to most gtc functions

Browse Source
This commit is contained in:
Jesse Talavera-Greenberg 2015-09-11 19:32:48 -04:00
parent f7f1239bb7
commit b633ead29f
25 changed files with 527 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
glm/gtc/bitfield.hpp
View File

@ -62,173 +62,173 @@ namespace glm
///
/// @see gtc_bitfield
template <typename genIUType>
GLM_FUNC_DECL genIUType mask(genIUType Bits);
GLM_FUNC_DECL genIUType mask(genIUType Bits) GLM_NOEXCEPT;
/// Build a mask of 'count' bits
///
/// @see gtc_bitfield
template <typename T, precision P, template <typename, precision> class vecIUType>
GLM_FUNC_DECL vecIUType<T, P> mask(vecIUType<T, P> const & v);
GLM_FUNC_DECL vecIUType<T, P> mask(vecIUType<T, P> const & v) GLM_NOEXCEPT;
/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
///
/// @see gtc_bitfield
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift);
GLM_FUNC_DECL genIUType bitfieldRotateRight(genIUType In, int Shift) GLM_NOEXCEPT;
/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
///
/// @see gtc_bitfield
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift);
GLM_FUNC_DECL vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift) GLM_NOEXCEPT;
/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
///
/// @see gtc_bitfield
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift);
GLM_FUNC_DECL genIUType bitfieldRotateLeft(genIUType In, int Shift) GLM_NOEXCEPT;
/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
///
/// @see gtc_bitfield
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift);
GLM_FUNC_DECL vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift) GLM_NOEXCEPT;
/// Set to 1 a range of bits.
///
/// @see gtc_bitfield
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount);
GLM_FUNC_DECL genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount) GLM_NOEXCEPT;
/// Set to 1 a range of bits.
///
/// @see gtc_bitfield
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount);
GLM_FUNC_DECL vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount) GLM_NOEXCEPT;
/// Set to 0 a range of bits.
///
/// @see gtc_bitfield
template <typename genIUType>
GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount);
GLM_FUNC_DECL genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount) GLM_NOEXCEPT;
/// Set to 0 a range of bits.
///
/// @see gtc_bitfield
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount);
GLM_FUNC_DECL vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y) GLM_NOEXCEPT;
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z) GLM_NOEXCEPT;
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w) GLM_NOEXCEPT;
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w) GLM_NOEXCEPT;
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w) GLM_NOEXCEPT;
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtc_bitfield
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w) GLM_NOEXCEPT;
/// @}
} //namespace glm

74
glm/gtc/bitfield.inl
View File

@ -34,16 +34,16 @@ namespace glm{
namespace detail
{
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y) GLM_NOEXCEPT;
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z) GLM_NOEXCEPT;
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w) GLM_NOEXCEPT;
template <>
GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y) GLM_NOEXCEPT
{
glm::uint16 REG1(x);
glm::uint16 REG2(y);
@ -61,7 +61,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y) GLM_NOEXCEPT
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
@ -82,7 +82,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y) GLM_NOEXCEPT
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
@ -106,7 +106,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z) GLM_NOEXCEPT
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
@ -132,7 +132,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z) GLM_NOEXCEPT
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
@ -162,7 +162,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z) GLM_NOEXCEPT
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
@ -192,7 +192,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w) GLM_NOEXCEPT
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
@ -218,7 +218,7 @@ namespace detail
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w) GLM_NOEXCEPT
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
@ -250,7 +250,7 @@ namespace detail
}//namespace detail
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits)
GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'mask' accepts only integer values");
@ -258,7 +258,7 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecIUType>
GLM_FUNC_QUALIFIER vecIUType<T, P> mask(vecIUType<T, P> const & v)
GLM_FUNC_QUALIFIER vecIUType<T, P> mask(vecIUType<T, P> const & v) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");
@ -266,7 +266,7 @@ namespace detail
}
template <typename genIType>
GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift)
GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateRight' accepts only integer values");
@ -275,7 +275,7 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift)
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");
@ -284,7 +284,7 @@ namespace detail
}
template <typename genIType>
GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift)
GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
@ -293,7 +293,7 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift)
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
@ -302,30 +302,30 @@ namespace detail
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)
GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount) GLM_NOEXCEPT
{
return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount)
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount) GLM_NOEXCEPT
{
return Value | static_cast<T>(mask(BitCount) << FirstBit);
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)
GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount) GLM_NOEXCEPT
{
return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount)
GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount) GLM_NOEXCEPT
{
return Value & static_cast<T>(~(mask(BitCount) << FirstBit));
}
GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)
GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y) GLM_NOEXCEPT
{
union sign8
{
@ -346,12 +346,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)
GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint8, uint16>(x, y);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y) GLM_NOEXCEPT
{
union sign16
{
@ -372,12 +372,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint16, uint32>(x, y);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y) GLM_NOEXCEPT
{
union sign32
{
@ -398,12 +398,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint32, uint64>(x, y);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z) GLM_NOEXCEPT
{
union sign8
{
@ -425,12 +425,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint8, uint32>(x, y, z);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z) GLM_NOEXCEPT
{
union sign16
{
@ -452,12 +452,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z) GLM_NOEXCEPT
{
union sign16
{
@ -479,12 +479,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w) GLM_NOEXCEPT
{
union sign8
{
@ -507,12 +507,12 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w) GLM_NOEXCEPT
{
union sign16
{
@ -535,7 +535,7 @@ namespace detail
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w) GLM_NOEXCEPT
{
return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);
}

8
glm/gtc/color_space.hpp
View File

@ -61,19 +61,19 @@ namespace glm
/// Convert a linear color to sRGB color using a standard gamma correction
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear);
GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear) GLM_NOEXCEPT;
/// Convert a linear color to sRGB color using a custom gamma correction
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma);
GLM_FUNC_DECL vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma) GLM_NOEXCEPT;
/// Convert a sRGB color to linear color using a standard gamma correction
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB);
GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB) GLM_NOEXCEPT;
/// Convert a sRGB color to linear color using a custom gamma correction
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma);
GLM_FUNC_DECL vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma) GLM_NOEXCEPT;
/// @}
} //namespace glm

16
glm/gtc/color_space.inl
View File

@ -36,7 +36,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType>
struct compute_rgbToSrgb
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & ColorRGB, T GammaCorrection)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & ColorRGB, T GammaCorrection) GLM_NOEXCEPT
{
vecType<T, P> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
@ -50,7 +50,7 @@ namespace detail
template <typename T, precision P>
struct compute_rgbToSrgb<T, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & ColorRGB, T GammaCorrection)
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & ColorRGB, T GammaCorrection) GLM_NOEXCEPT
{
return tvec4<T, P>(compute_rgbToSrgb<T, P, tvec3>::call(tvec3<T, P>(ColorRGB), GammaCorrection), ColorRGB.a);
}
@ -59,7 +59,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType>
struct compute_srgbToRgb
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & ColorSRGB, T Gamma)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & ColorSRGB, T Gamma) GLM_NOEXCEPT
{
return mix(
pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vecType<T, P>(Gamma)),
@ -71,7 +71,7 @@ namespace detail
template <typename T, precision P>
struct compute_srgbToRgb<T, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & ColorSRGB, T Gamma)
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & ColorSRGB, T Gamma) GLM_NOEXCEPT
{
return tvec4<T, P>(compute_srgbToRgb<T, P, tvec3>::call(tvec3<T, P>(ColorSRGB), Gamma), ColorSRGB.a);
}
@ -79,25 +79,25 @@ namespace detail
}//namespace detail
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear)
GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear) GLM_NOEXCEPT
{
return detail::compute_rgbToSrgb<T, P, vecType>::call(ColorLinear, static_cast<T>(0.41666));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma)
GLM_FUNC_QUALIFIER vecType<T, P> convertLinearToSRGB(vecType<T, P> const & ColorLinear, T Gamma) GLM_NOEXCEPT
{
return detail::compute_rgbToSrgb<T, P, vecType>::call(ColorLinear, static_cast<T>(1) / Gamma);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB)
GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB) GLM_NOEXCEPT
{
return detail::compute_srgbToRgb<T, P, vecType>::call(ColorSRGB, static_cast<T>(2.4));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma)
GLM_FUNC_QUALIFIER vecType<T, P> convertSRGBToLinear(vecType<T, P> const & ColorSRGB, T Gamma) GLM_NOEXCEPT
{
return detail::compute_srgbToRgb<T, P, vecType>::call(ColorSRGB, Gamma);
}

58
glm/gtc/constants.hpp
View File

@ -57,147 +57,147 @@ namespace glm
/// Return the epsilon constant for floating point types.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon() GLM_NOEXCEPT;
/// Return 0.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType zero();
GLM_FUNC_DECL GLM_CONSTEXPR genType zero() GLM_NOEXCEPT;
/// Return 1.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType one();
GLM_FUNC_DECL GLM_CONSTEXPR genType one() GLM_NOEXCEPT;
/// Return the pi constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType pi() GLM_NOEXCEPT;
/// Return pi * 2.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType two_pi() GLM_NOEXCEPT;
/// Return square root of pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_pi() GLM_NOEXCEPT;
/// Return pi / 2.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType half_pi() GLM_NOEXCEPT;
/// Return pi / 2 * 3.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType three_over_two_pi() GLM_NOEXCEPT;
/// Return pi / 4.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType quarter_pi() GLM_NOEXCEPT;
/// Return 1 / pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_pi() GLM_NOEXCEPT;
/// Return 1 / (pi * 2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_two_pi() GLM_NOEXCEPT;
/// Return 2 / pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_pi() GLM_NOEXCEPT;
/// Return 4 / pi.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType four_over_pi() GLM_NOEXCEPT;
/// Return 2 / sqrt(pi).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType two_over_root_pi() GLM_NOEXCEPT;
/// Return 1 / sqrt(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two();
GLM_FUNC_DECL GLM_CONSTEXPR genType one_over_root_two() GLM_NOEXCEPT;
/// Return sqrt(pi / 2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_half_pi() GLM_NOEXCEPT;
/// Return sqrt(2 * pi).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two_pi() GLM_NOEXCEPT;
/// Return sqrt(ln(4)).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_ln_four() GLM_NOEXCEPT;
/// Return e constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType e();
GLM_FUNC_DECL GLM_CONSTEXPR genType e() GLM_NOEXCEPT;
/// Return Euler's constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType euler();
GLM_FUNC_DECL GLM_CONSTEXPR genType euler() GLM_NOEXCEPT;
/// Return sqrt(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_two() GLM_NOEXCEPT;
/// Return sqrt(3).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_three();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_three() GLM_NOEXCEPT;
/// Return sqrt(5).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType root_five();
GLM_FUNC_DECL GLM_CONSTEXPR genType root_five() GLM_NOEXCEPT;
/// Return ln(2).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two();
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_two() GLM_NOEXCEPT;
/// Return ln(10).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten();
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ten() GLM_NOEXCEPT;
/// Return ln(ln(2)).
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two();
GLM_FUNC_DECL GLM_CONSTEXPR genType ln_ln_two() GLM_NOEXCEPT;
/// Return 1 / 3.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType third();
GLM_FUNC_DECL GLM_CONSTEXPR genType third() GLM_NOEXCEPT;
/// Return 2 / 3.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds();
GLM_FUNC_DECL GLM_CONSTEXPR genType two_thirds() GLM_NOEXCEPT;
/// Return the golden ratio constant.
/// @see gtc_constants
template <typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio();
GLM_FUNC_DECL GLM_CONSTEXPR genType golden_ratio() GLM_NOEXCEPT;
/// @}
} //namespace glm

58
glm/gtc/constants.inl
View File

@ -35,175 +35,175 @@
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() GLM_NOEXCEPT
{
return std::numeric_limits<genType>::epsilon();
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero() GLM_NOEXCEPT
{
return genType(0);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one() GLM_NOEXCEPT
{
return genType(1);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() GLM_NOEXCEPT
{
return genType(3.14159265358979323846264338327950288);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi() GLM_NOEXCEPT
{
return genType(6.28318530717958647692528676655900576);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_pi() GLM_NOEXCEPT
{
return genType(1.772453850905516027);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType half_pi() GLM_NOEXCEPT
{
return genType(1.57079632679489661923132169163975144);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType three_over_two_pi() GLM_NOEXCEPT
{
return genType(4.71238898038468985769396507491925432);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType quarter_pi() GLM_NOEXCEPT
{
return genType(0.785398163397448309615660845819875721);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_pi() GLM_NOEXCEPT
{
return genType(0.318309886183790671537767526745028724);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_two_pi() GLM_NOEXCEPT
{
return genType(0.159154943091895335768883763372514362);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_pi() GLM_NOEXCEPT
{
return genType(0.636619772367581343075535053490057448);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType four_over_pi() GLM_NOEXCEPT
{
return genType(1.273239544735162686151070106980114898);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_over_root_pi() GLM_NOEXCEPT
{
return genType(1.12837916709551257389615890312154517);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType one_over_root_two() GLM_NOEXCEPT
{
return genType(0.707106781186547524400844362104849039);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_half_pi() GLM_NOEXCEPT
{
return genType(1.253314137315500251);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two_pi() GLM_NOEXCEPT
{
return genType(2.506628274631000502);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_ln_four() GLM_NOEXCEPT
{
return genType(1.17741002251547469);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType e() GLM_NOEXCEPT
{
return genType(2.71828182845904523536);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType euler() GLM_NOEXCEPT
{
return genType(0.577215664901532860606);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_two() GLM_NOEXCEPT
{
return genType(1.41421356237309504880168872420969808);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_three() GLM_NOEXCEPT
{
return genType(1.73205080756887729352744634150587236);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType root_five() GLM_NOEXCEPT
{
return genType(2.23606797749978969640917366873127623);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_two() GLM_NOEXCEPT
{
return genType(0.693147180559945309417232121458176568);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ten() GLM_NOEXCEPT
{
return genType(2.30258509299404568401799145468436421);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType ln_ln_two() GLM_NOEXCEPT
{
return genType(-0.3665129205816643);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType third() GLM_NOEXCEPT
{
return genType(0.3333333333333333333333333333333333333333);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_thirds() GLM_NOEXCEPT
{
return genType(0.666666666666666666666666666666666666667);
}
template <typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType golden_ratio() GLM_NOEXCEPT
{
return genType(1.61803398874989484820458683436563811);
}

8
glm/gtc/integer.hpp
View File

@ -62,7 +62,7 @@ namespace glm
/// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size.
/// @see gtc_integer
template <typename genIUType>
GLM_FUNC_DECL genIUType log2(genIUType x);
GLM_FUNC_DECL genIUType log2(genIUType x) GLM_NOEXCEPT;
/// Modulus. Returns x % y
/// for each component in x using the floating point value y.
@ -73,7 +73,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genIUType>
GLM_FUNC_DECL genIUType mod(genIUType x, genIUType y);
GLM_FUNC_DECL genIUType mod(genIUType x, genIUType y) GLM_NOEXCEPT;
/// Modulus. Returns x % y
/// for each component in x using the floating point value y.
@ -85,7 +85,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y) GLM_NOEXCEPT;
/// Modulus. Returns x % y
/// for each component in x using the floating point value y.
@ -97,7 +97,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y) GLM_NOEXCEPT;
/// @}
} //namespace glm

4
glm/gtc/integer.inl
View File

@ -36,7 +36,7 @@ namespace detail
template <typename T, precision P, template <class, precision> class vecType>
struct compute_log2<T, P, vecType, false>
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec) GLM_NOEXCEPT
{
//Equivalent to return findMSB(vec); but save one function call in ASM with VC
//return findMSB(vec);
@ -48,7 +48,7 @@ namespace detail
template <precision P>
struct compute_log2<int, P, tvec4, false>
{
GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & vec)
GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & vec) GLM_NOEXCEPT
{
tvec4<int, P> Result(glm::uninitialize);

4
glm/gtc/matrix_inverse.hpp
View File

@ -62,7 +62,7 @@ namespace glm
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template <typename genType>
GLM_FUNC_DECL genType affineInverse(genType const & m);
GLM_FUNC_DECL genType affineInverse(genType const & m) GLM_NOEXCEPT;
/// Compute the inverse transpose of a matrix.
///
@ -70,7 +70,7 @@ namespace glm
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template <typename genType>
GLM_FUNC_DECL genType inverseTranspose(genType const & m);
GLM_FUNC_DECL genType inverseTranspose(genType const & m) GLM_NOEXCEPT;
/// @}
}//namespace glm

10
glm/gtc/matrix_inverse.inl
View File

@ -33,7 +33,7 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat3x3<T, P> affineInverse(tmat3x3<T, P> const & m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> affineInverse(tmat3x3<T, P> const & m) GLM_NOEXCEPT
{
tmat3x3<T, P> Result(m);
Result[2] = tvec3<T, P>(0, 0, 1);
@ -44,7 +44,7 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat4x4<T, P> affineInverse(tmat4x4<T, P> const & m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> affineInverse(tmat4x4<T, P> const & m) GLM_NOEXCEPT
{
tmat4x4<T, P> Result(m);
Result[3] = tvec4<T, P>(0, 0, 0, 1);
@ -55,7 +55,7 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat2x2<T, P> inverseTranspose(tmat2x2<T, P> const & m)
GLM_FUNC_QUALIFIER tmat2x2<T, P> inverseTranspose(tmat2x2<T, P> const & m) GLM_NOEXCEPT
{
T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
@ -69,7 +69,7 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat3x3<T, P> inverseTranspose(tmat3x3<T, P> const & m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> inverseTranspose(tmat3x3<T, P> const & m) GLM_NOEXCEPT
{
T Determinant =
+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
@ -92,7 +92,7 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat4x4<T, P> inverseTranspose(tmat4x4<T, P> const & m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> inverseTranspose(tmat4x4<T, P> const & m) GLM_NOEXCEPT
{
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];

6
glm/gtc/noise.hpp
View File

@ -68,20 +68,20 @@ namespace glm
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T perlin(
vecType<T, P> const & p);
vecType<T, P> const & p) GLM_NOEXCEPT;
/// Periodic perlin noise.
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T perlin(
vecType<T, P> const & p,
vecType<T, P> const & rep);
vecType<T, P> const & rep) GLM_NOEXCEPT;
/// Simplex noise.
/// @see gtc_noise
template <typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_DECL T simplex(
vecType<T, P> const & p);
vecType<T, P> const & p) GLM_NOEXCEPT;
/// @}
}//namespace glm

22
glm/gtc/noise.inl
View File

@ -39,7 +39,7 @@ namespace glm{
namespace gtc
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip) GLM_NOEXCEPT
{
tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
@ -51,7 +51,7 @@ namespace gtc
// Classic Perlin noise
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position)
GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position) GLM_NOEXCEPT
{
tvec4<T, P> Pi = glm::floor(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) + tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
tvec4<T, P> Pf = glm::fract(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) - tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
@ -92,7 +92,7 @@ namespace gtc
// Classic Perlin noise
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position)
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position) GLM_NOEXCEPT
{
tvec3<T, P> Pi0 = floor(Position); // Integer part for indexing
tvec3<T, P> Pi1 = Pi0 + T(1); // Integer part + 1
@ -163,7 +163,7 @@ namespace gtc
/*
// Classic Perlin noise
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & P)
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & P) GLM_NOEXCEPT
{
tvec3<T, P> Pi0 = floor(P); // Integer part for indexing
tvec3<T, P> Pi1 = Pi0 + T(1); // Integer part + 1
@ -236,7 +236,7 @@ namespace gtc
*/
// Classic Perlin noise
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position)
GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position) GLM_NOEXCEPT
{
tvec4<T, P> Pi0 = floor(Position); // Integer part for indexing
tvec4<T, P> Pi1 = Pi0 + T(1); // Integer part + 1
@ -372,7 +372,7 @@ namespace gtc
// Classic Perlin noise, periodic variant
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position, tvec2<T, P> const & rep)
GLM_FUNC_QUALIFIER T perlin(tvec2<T, P> const & Position, tvec2<T, P> const & rep) GLM_NOEXCEPT
{
tvec4<T, P> Pi = floor(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) + tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
tvec4<T, P> Pf = fract(tvec4<T, P>(Position.x, Position.y, Position.x, Position.y)) - tvec4<T, P>(0.0, 0.0, 1.0, 1.0);
@ -414,7 +414,7 @@ namespace gtc
// Classic Perlin noise, periodic variant
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position, tvec3<T, P> const & rep)
GLM_FUNC_QUALIFIER T perlin(tvec3<T, P> const & Position, tvec3<T, P> const & rep) GLM_NOEXCEPT
{
tvec3<T, P> Pi0 = mod(floor(Position), rep); // Integer part, modulo period
tvec3<T, P> Pi1 = mod(Pi0 + tvec3<T, P>(T(1)), rep); // Integer part + 1, mod period
@ -485,7 +485,7 @@ namespace gtc
// Classic Perlin noise, periodic version
template <typename T, precision P>
GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position, tvec4<T, P> const & rep)
GLM_FUNC_QUALIFIER T perlin(tvec4<T, P> const & Position, tvec4<T, P> const & rep) GLM_NOEXCEPT
{
tvec4<T, P> Pi0 = mod(floor(Position), rep); // Integer part modulo rep
tvec4<T, P> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
@ -618,7 +618,7 @@ namespace gtc
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T simplex(glm::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER T simplex(glm::tvec2<T, P> const & v) GLM_NOEXCEPT
{
tvec4<T, P> const C = tvec4<T, P>(
T( 0.211324865405187), // (3.0 - sqrt(3.0)) / 6.0
@ -675,7 +675,7 @@ namespace gtc
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T simplex(tvec3<T, P> const & v)
GLM_FUNC_QUALIFIER T simplex(tvec3<T, P> const & v) GLM_NOEXCEPT
{
tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
@ -750,7 +750,7 @@ namespace gtc
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T simplex(tvec4<T, P> const & v)
GLM_FUNC_QUALIFIER T simplex(tvec4<T, P> const & v) GLM_NOEXCEPT
{
tvec4<T, P> const C(
0.138196601125011, // (5 - sqrt(5))/20 G4

60
glm/gtc/packing.hpp
View File

@ -65,7 +65,7 @@ namespace glm
/// @see uint32 packUnorm4x8(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint8 packUnorm1x8(float v);
GLM_FUNC_DECL uint8 packUnorm1x8(float v) GLM_NOEXCEPT;
/// Convert a single 8-bit integer to a normalized floating-point value.
///
@ -77,7 +77,7 @@ namespace glm
/// @see vec4 unpackUnorm4x8(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL float unpackUnorm1x8(uint8 p);
GLM_FUNC_DECL float unpackUnorm1x8(uint8 p) GLM_NOEXCEPT;
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -93,7 +93,7 @@ namespace glm
/// @see uint32 packUnorm4x8(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const & v);
GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
@ -109,8 +109,8 @@ namespace glm
/// @see vec4 unpackUnorm4x8(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p);
GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p) GLM_NOEXCEPT;
/// First, converts the normalized floating-point value v into 8-bit integer value.
/// Then, the results are packed into the returned 8-bit unsigned integer.
///
@ -122,7 +122,7 @@ namespace glm
/// @see uint32 packSnorm4x8(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint8 packSnorm1x8(float s);
GLM_FUNC_DECL uint8 packSnorm1x8(float s) GLM_NOEXCEPT;
/// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@ -135,7 +135,7 @@ namespace glm
/// @see vec4 unpackSnorm4x8(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL float unpackSnorm1x8(uint8 p);
GLM_FUNC_DECL float unpackSnorm1x8(uint8 p) GLM_NOEXCEPT;
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -151,7 +151,7 @@ namespace glm
/// @see uint32 packSnorm4x8(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const & v);
GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
@ -167,7 +167,7 @@ namespace glm
/// @see vec4 unpackSnorm4x8(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p);
GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p) GLM_NOEXCEPT;
/// First, converts the normalized floating-point value v into a 16-bit integer value.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -180,7 +180,7 @@ namespace glm
/// @see uint64 packSnorm4x16(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint16 packUnorm1x16(float v);
GLM_FUNC_DECL uint16 packUnorm1x16(float v) GLM_NOEXCEPT;
/// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@ -193,7 +193,7 @@ namespace glm
/// @see vec4 unpackUnorm4x16(uint64 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL float unpackUnorm1x16(uint16 p);
GLM_FUNC_DECL float unpackUnorm1x16(uint16 p) GLM_NOEXCEPT;
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
/// Then, the results are packed into the returned 64-bit unsigned integer.
@ -209,7 +209,7 @@ namespace glm
/// @see uint32 packUnorm2x16(vec2 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const & v);
GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -225,7 +225,7 @@ namespace glm
/// @see vec2 unpackUnorm2x16(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p);
GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p) GLM_NOEXCEPT;
/// First, converts the normalized floating-point value v into 16-bit integer value.
/// Then, the results are packed into the returned 16-bit unsigned integer.
@ -238,7 +238,7 @@ namespace glm
/// @see uint64 packSnorm4x16(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint16 packSnorm1x16(float v);
GLM_FUNC_DECL uint16 packSnorm1x16(float v) GLM_NOEXCEPT;
/// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned scalar.
@ -251,7 +251,7 @@ namespace glm
/// @see vec4 unpackSnorm4x16(uint64 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm1x16.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL float unpackSnorm1x16(uint16 p);
GLM_FUNC_DECL float unpackSnorm1x16(uint16 p) GLM_NOEXCEPT;
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
/// Then, the results are packed into the returned 64-bit unsigned integer.
@ -267,7 +267,7 @@ namespace glm
/// @see uint32 packSnorm2x16(vec2 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const & v);
GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -283,7 +283,7 @@ namespace glm
/// @see vec2 unpackSnorm2x16(uint32 p)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm4x8 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p);
GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p) GLM_NOEXCEPT;
/// Returns an unsigned integer obtained by converting the components of a floating-point scalar
/// to the 16-bit floating-point representation found in the OpenGL Specification,
@ -294,7 +294,7 @@ namespace glm
/// @see uint64 packHalf4x16(vec4 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint16 packHalf1x16(float v);
GLM_FUNC_DECL uint16 packHalf1x16(float v) GLM_NOEXCEPT;
/// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value,
/// interpreted as a 16-bit floating-point number according to the OpenGL Specification,
@ -305,7 +305,7 @@ namespace glm
/// @see vec4 unpackHalf4x16(uint64 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL float unpackHalf1x16(uint16 v);
GLM_FUNC_DECL float unpackHalf1x16(uint16 v) GLM_NOEXCEPT;
/// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector
/// to the 16-bit floating-point representation found in the OpenGL Specification,
@ -318,7 +318,7 @@ namespace glm
/// @see uint32 packHalf2x16(vec2 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL uint64 packHalf4x16(vec4 const & v);
GLM_FUNC_DECL uint64 packHalf4x16(vec4 const & v) GLM_NOEXCEPT;
/// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values,
/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
@ -331,7 +331,7 @@ namespace glm
/// @see vec2 unpackHalf2x16(uint32 const & v)
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p);
GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p) GLM_NOEXCEPT;
/// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector
/// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification,
@ -344,7 +344,7 @@ namespace glm
/// @see uint32 packSnorm3x10_1x2(vec4 const & v)
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see ivec4 unpackI3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const & v);
GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const & v) GLM_NOEXCEPT;
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit signed integers.
///
@ -355,7 +355,7 @@ namespace glm
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p);
GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p) GLM_NOEXCEPT;
/// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector
/// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification,
@ -368,7 +368,7 @@ namespace glm
/// @see uint32 packSnorm3x10_1x2(vec4 const & v)
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see ivec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const & v);
GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const & v) GLM_NOEXCEPT;
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit unsigned integers.
///
@ -379,7 +379,7 @@ namespace glm
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p);
GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p) GLM_NOEXCEPT;
/// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values.
@ -397,7 +397,7 @@ namespace glm
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const & v);
GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -414,7 +414,7 @@ namespace glm
/// @see vec4 unpackUnorm3x10_1x2(uint32 const & p))
/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p);
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p) GLM_NOEXCEPT;
/// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values.
@ -432,7 +432,7 @@ namespace glm
/// @see uint32 packUnorm3x10_1x2(vec4 const & v)
/// @see uint32 packU3x10_1x2(uvec4 const & v)
/// @see uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const & v);
GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
@ -449,7 +449,7 @@ namespace glm
/// @see vec4 unpackInorm3x10_1x2(uint32 const & p))
/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p);
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p) GLM_NOEXCEPT;
/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
@ -460,7 +460,7 @@ namespace glm
///
/// @see gtc_packing
/// @see vec3 unpackF2x11_1x10(uint32 const & p)
GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const & v);
GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const & v) GLM_NOEXCEPT;
/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
/// Then, each component is converted to a normalized floating-point value to generate the returned three-component vector.
@ -470,7 +470,7 @@ namespace glm
///
/// @see gtc_packing
/// @see uint32 packF2x11_1x10(vec3 const & v)
GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p);
GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p) GLM_NOEXCEPT;
/// @}
}// namespace glm

82
glm/gtc/packing.inl
View File

@ -40,7 +40,7 @@
namespace glm{
namespace detail
{
GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)
GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f) GLM_NOEXCEPT
{
// 10 bits => EE EEEFFFFF
// 11 bits => EEE EEFFFFFF
@ -58,7 +58,7 @@ namespace detail
((f >> 13) & 0x03ff); // Mantissa
}
GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f)
GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f) GLM_NOEXCEPT
{
// 10 bits => EE EEEFFFFF
// 11 bits => EEE EEFFFFFF
@ -76,7 +76,7 @@ namespace detail
((f >> 17) & 0x003f); // Mantissa
}
GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p)
GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p) GLM_NOEXCEPT
{
// 10 bits => EE EEEFFFFF
// 11 bits => EEE EEFFFFFF
@ -94,7 +94,7 @@ namespace detail
((p & 0x003f) << 17); // Mantissa
}
GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f)
GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f) GLM_NOEXCEPT
{
// 10 bits => EE EEEFFFFF
// 11 bits => EEE EEFFFFFF
@ -115,7 +115,7 @@ namespace detail
((f >> 18) & 0x001f); // Mantissa
}
GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p)
GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p) GLM_NOEXCEPT
{
// 10 bits => EE EEEFFFFF
// 11 bits => EEE EEFFFFFF
@ -136,12 +136,12 @@ namespace detail
((p & 0x001f) << 18); // Mantissa
}
GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)
GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h) GLM_NOEXCEPT
{
return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
}
GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x)
GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x) GLM_NOEXCEPT
{
if(x == 0.0f)
return 0u;
@ -160,7 +160,7 @@ namespace detail
return float2packed11(Pack);
}
GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x)
GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x) GLM_NOEXCEPT
{
if(x == 0)
return 0.0f;
@ -180,7 +180,7 @@ namespace detail
# endif
}
GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x)
GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x) GLM_NOEXCEPT
{
if(x == 0.0f)
return 0u;
@ -199,7 +199,7 @@ namespace detail
return float2packed10(Pack);
}
GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x)
GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x) GLM_NOEXCEPT
{
if(x == 0)
return 0.0f;
@ -219,7 +219,7 @@ namespace detail
# endif
}
// GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z)
// GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z) GLM_NOEXCEPT
// {
// return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) | ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22);
// }
@ -250,36 +250,36 @@ namespace detail
}//namespace detail
GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v)
GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v) GLM_NOEXCEPT
{
return static_cast<uint8>(round(clamp(v, 0.0f, 1.0f) * 255.0f));
}
GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p)
GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p) GLM_NOEXCEPT
{
float const Unpack(p);
return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255
}
GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const & v)
GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const & v) GLM_NOEXCEPT
{
u8vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
return reinterpret_cast<uint16 const &>(Topack);
}
GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p)
GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p) GLM_NOEXCEPT
{
vec2 const Unpack(reinterpret_cast<u8vec2 const &>(p));
return Unpack * float(0.0039215686274509803921568627451); // 1 / 255
}
GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v)
GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v) GLM_NOEXCEPT
{
int8 const Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
return reinterpret_cast<uint8 const &>(Topack);
}
GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p)
GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p) GLM_NOEXCEPT
{
float const Unpack(reinterpret_cast<int8 const &>(p));
return clamp(
@ -287,13 +287,13 @@ namespace detail
-1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const & v)
GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const & v) GLM_NOEXCEPT
{
i8vec2 const Topack(round(clamp(v, -1.0f, 1.0f) * 127.0f));
return reinterpret_cast<uint16 const &>(Topack);
}
GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p)
GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p) GLM_NOEXCEPT
{
vec2 const Unpack(reinterpret_cast<i8vec2 const &>(p));
return clamp(
@ -301,36 +301,36 @@ namespace detail
-1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s)
GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s) GLM_NOEXCEPT
{
return static_cast<uint16>(round(clamp(s, 0.0f, 1.0f) * 65535.0f));
}
GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p)
GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p) GLM_NOEXCEPT
{
float const Unpack(p);
return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
}
GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const & v)
GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const & v) GLM_NOEXCEPT
{
u16vec4 const Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f));
return reinterpret_cast<uint64 const &>(Topack);
}
GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p)
GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p) GLM_NOEXCEPT
{
vec4 const Unpack(reinterpret_cast<u16vec4 const &>(p));
return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
}
GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v)
GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v) GLM_NOEXCEPT
{
int16 const Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
return reinterpret_cast<uint16 const &>(Topack);
}
GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p)
GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p) GLM_NOEXCEPT
{
float const Unpack(reinterpret_cast<int16 const &>(p));
return clamp(
@ -338,13 +338,13 @@ namespace detail
-1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const & v)
GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const & v) GLM_NOEXCEPT
{
i16vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
return reinterpret_cast<uint64 const &>(Topack);
}
GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p)
GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p) GLM_NOEXCEPT
{
vec4 const Unpack(reinterpret_cast<i16vec4 const &>(p));
return clamp(
@ -352,18 +352,18 @@ namespace detail
-1.0f, 1.0f);
}
GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v)
GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v) GLM_NOEXCEPT
{
int16 const Topack(detail::toFloat16(v));
return reinterpret_cast<uint16 const &>(Topack);
}
GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v)
GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v) GLM_NOEXCEPT
{
return detail::toFloat32(reinterpret_cast<int16 const &>(v));
}
GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const & v)
GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const & v) GLM_NOEXCEPT
{
i16vec4 Unpack(
detail::toFloat16(v.x),
@ -374,7 +374,7 @@ namespace detail
return reinterpret_cast<uint64 const &>(Unpack);
}
GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v)
GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v) GLM_NOEXCEPT
{
i16vec4 Unpack(reinterpret_cast<i16vec4 const &>(v));
@ -385,7 +385,7 @@ namespace detail
detail::toFloat32(Unpack.w));
}
GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const & v)
GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const & v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Result;
Result.data.x = v.x;
@ -395,7 +395,7 @@ namespace detail
return Result.pack;
}
GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v)
GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Unpack;
Unpack.pack = v;
@ -406,7 +406,7 @@ namespace detail
Unpack.data.w);
}
GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const & v)
GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const & v) GLM_NOEXCEPT
{
detail::u10u10u10u2 Result;
Result.data.x = v.x;
@ -416,7 +416,7 @@ namespace detail
return Result.pack;
}
GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v)
GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v) GLM_NOEXCEPT
{
detail::u10u10u10u2 Unpack;
Unpack.pack = v;
@ -427,7 +427,7 @@ namespace detail
Unpack.data.w);
}
GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const & v)
GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const & v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Result;
Result.data.x = int(round(clamp(v.x,-1.0f, 1.0f) * 511.f));
@ -437,7 +437,7 @@ namespace detail
return Result.pack;
}
GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v)
GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Unpack;
Unpack.pack = v;
@ -449,7 +449,7 @@ namespace detail
return Result;
}
GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const & v)
GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const & v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Result;
Result.data.x = int(round(clamp(v.x, 0.0f, 1.0f) * 1023.f));
@ -459,7 +459,7 @@ namespace detail
return Result.pack;
}
GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v)
GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v) GLM_NOEXCEPT
{
detail::i10i10i10i2 Unpack;
Unpack.pack = v;
@ -471,7 +471,7 @@ namespace detail
return Result;
}
GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const & v)
GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const & v) GLM_NOEXCEPT
{
return
((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) |
@ -479,7 +479,7 @@ namespace detail
((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22);
}
GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v)
GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v) GLM_NOEXCEPT
{
return vec3(
detail::packed11bitToFloat(v >> 0),

2
glm/gtc/quaternion.hpp
View File

@ -197,7 +197,7 @@ namespace glm
///
/// @see gtc_quaternion
template <typename T, precision P, template <typename, precision> class quatType>
GLM_FUNC_DECL T dot(quatType<T, P> const & x, quatType<T, P> const & y);
GLM_FUNC_DECL T dot(quatType<T, P> const & x, quatType<T, P> const & y) GLM_NOEXCEPT;
/// Spherical linear interpolation of two quaternions.
/// The interpolation is oriented and the rotation is performed at constant speed.

14
glm/gtc/random.hpp
View File

@ -65,12 +65,12 @@ namespace glm
template <typename genTYpe>
GLM_FUNC_DECL genTYpe linearRand(
genTYpe Min,
genTYpe Max);
genTYpe Max) GLM_NOEXCEPT;
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> linearRand(
vecType<T, P> const & Min,
vecType<T, P> const & Max);
vecType<T, P> const & Max) GLM_NOEXCEPT;
/// Generate random numbers in the interval [Min, Max], according a gaussian distribution
///
@ -80,7 +80,7 @@ namespace glm
template <typename genType>
GLM_FUNC_DECL genType gaussRand(
genType Mean,
genType Deviation);
genType Deviation) GLM_NOEXCEPT;
/// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius
///
@ -88,7 +88,7 @@ namespace glm
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
T Radius);
T Radius) GLM_NOEXCEPT;
/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
///
@ -96,7 +96,7 @@ namespace glm
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
T Radius);
T Radius) GLM_NOEXCEPT;
/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
///
@ -104,7 +104,7 @@ namespace glm
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
T Radius);
T Radius) GLM_NOEXCEPT;
/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
///
@ -112,7 +112,7 @@ namespace glm
/// @see gtc_random
template <typename T>
GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
T Radius);
T Radius) GLM_NOEXCEPT;
/// @}
}//namespace glm

69
glm/gtc/random.inl
View File

@ -42,13 +42,13 @@ namespace detail
template <typename T, precision P, template <class, precision> class vecType>
struct compute_rand
{
GLM_FUNC_QUALIFIER static vecType<T, P> call();
GLM_FUNC_QUALIFIER static vecType<T, P> call() GLM_NOEXCEPT;
};
template <precision P>
struct compute_rand<uint8, P, tvec1>
{
GLM_FUNC_QUALIFIER static tvec1<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec1<uint8, P> call() GLM_NOEXCEPT
{
return tvec1<uint8, P>(
std::rand() % std::numeric_limits<uint8>::max());
@ -58,7 +58,7 @@ namespace detail
template <precision P>
struct compute_rand<uint8, P, tvec2>
{
GLM_FUNC_QUALIFIER static tvec2<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec2<uint8, P> call() GLM_NOEXCEPT
{
return tvec2<uint8, P>(
std::rand() % std::numeric_limits<uint8>::max(),
@ -69,7 +69,7 @@ namespace detail
template <precision P>
struct compute_rand<uint8, P, tvec3>
{
GLM_FUNC_QUALIFIER static tvec3<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec3<uint8, P> call() GLM_NOEXCEPT
{
return tvec3<uint8, P>(
std::rand() % std::numeric_limits<uint8>::max(),
@ -81,7 +81,7 @@ namespace detail
template <precision P>
struct compute_rand<uint8, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<uint8, P> call()
GLM_FUNC_QUALIFIER static tvec4<uint8, P> call() GLM_NOEXCEPT
{
return tvec4<uint8, P>(
std::rand() % std::numeric_limits<uint8>::max(),
@ -94,7 +94,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_rand<uint16, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint16, P> call()
GLM_FUNC_QUALIFIER static vecType<uint16, P> call() GLM_NOEXCEPT
{
return
(vecType<uint16, P>(compute_rand<uint8, P, vecType>::call()) << static_cast<uint16>(8)) |
@ -105,7 +105,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_rand<uint32, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint32, P> call()
GLM_FUNC_QUALIFIER static vecType<uint32, P> call() GLM_NOEXCEPT
{
return
(vecType<uint32, P>(compute_rand<uint16, P, vecType>::call()) << static_cast<uint32>(16)) |
@ -116,7 +116,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_rand<uint64, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint64, P> call()
GLM_FUNC_QUALIFIER static vecType<uint64, P> call() GLM_NOEXCEPT
{
return
(vecType<uint64, P>(compute_rand<uint32, P, vecType>::call()) << static_cast<uint64>(32)) |
@ -127,13 +127,13 @@ namespace detail
template <typename T, precision P, template <class, precision> class vecType>
struct compute_linearRand
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & Min, vecType<T, P> const & Max);
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & Min, vecType<T, P> const & Max) GLM_NOEXCEPT;
};
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<int8, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<int8, P> call(vecType<int8, P> const & Min, vecType<int8, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<int8, P> call(vecType<int8, P> const & Min, vecType<int8, P> const & Max) GLM_NOEXCEPT
{
return (vecType<int8, P>(compute_rand<uint8, P, vecType>::call() % vecType<uint8, P>(Max + static_cast<int8>(1) - Min))) + Min;
}
@ -142,7 +142,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<uint8, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint8, P> call(vecType<uint8, P> const & Min, vecType<uint8, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<uint8, P> call(vecType<uint8, P> const & Min, vecType<uint8, P> const & Max) GLM_NOEXCEPT
{
return (compute_rand<uint8, P, vecType>::call() % (Max + static_cast<uint8>(1) - Min)) + Min;
}
@ -151,7 +151,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<int16, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<int16, P> call(vecType<int16, P> const & Min, vecType<int16, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<int16, P> call(vecType<int16, P> const & Min, vecType<int16, P> const & Max) GLM_NOEXCEPT
{
return (vecType<int16, P>(compute_rand<uint16, P, vecType>::call() % vecType<uint16, P>(Max + static_cast<int16>(1) - Min))) + Min;
}
@ -160,7 +160,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<uint16, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint16, P> call(vecType<uint16, P> const & Min, vecType<uint16, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<uint16, P> call(vecType<uint16, P> const & Min, vecType<uint16, P> const & Max) GLM_NOEXCEPT
{
return (compute_rand<uint16, P, vecType>::call() % (Max + static_cast<uint16>(1) - Min)) + Min;
}
@ -169,7 +169,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<int32, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<int32, P> call(vecType<int32, P> const & Min, vecType<int32, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<int32, P> call(vecType<int32, P> const & Min, vecType<int32, P> const & Max) GLM_NOEXCEPT
{
return (vecType<int32, P>(compute_rand<uint32, P, vecType>::call() % vecType<uint32, P>(Max + static_cast<int32>(1) - Min))) + Min;
}
@ -178,7 +178,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<uint32, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint32, P> call(vecType<uint32, P> const & Min, vecType<uint32, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<uint32, P> call(vecType<uint32, P> const & Min, vecType<uint32, P> const & Max) GLM_NOEXCEPT
{
return (compute_rand<uint32, P, vecType>::call() % (Max + static_cast<uint32>(1) - Min)) + Min;
}
@ -187,7 +187,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<int64, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<int64, P> call(vecType<int64, P> const & Min, vecType<int64, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<int64, P> call(vecType<int64, P> const & Min, vecType<int64, P> const & Max) GLM_NOEXCEPT
{
return (vecType<int64, P>(compute_rand<uint64, P, vecType>::call() % vecType<uint64, P>(Max + static_cast<int64>(1) - Min))) + Min;
}
@ -196,7 +196,7 @@ namespace detail
template <precision P, template <class, precision> class vecType>
struct compute_linearRand<uint64, P, vecType>
{
GLM_FUNC_QUALIFIER static vecType<uint64, P> call(vecType<uint64, P> const & Min, vecType<uint64, P> const & Max)
GLM_FUNC_QUALIFIER static vecType<uint64, P> call(vecType<uint64, P> const & Min, vecType<uint64, P> const & Max) GLM_NOEXCEPT
{
return (compute_rand<uint64, P, vecType>::call() % (Max + static_cast<uint64>(1) - Min)) + Min;
}
@ -205,7 +205,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<float, lowp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & Min, vecType<float, lowp> const & Max)
GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & Min, vecType<float, lowp> const & Max) GLM_NOEXCEPT
{
return vecType<float, lowp>(compute_rand<uint8, lowp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint8>::max()) * (Max - Min) + Min;
}
@ -214,7 +214,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<float, mediump, vecType>
{
GLM_FUNC_QUALIFIER static vecType<float, mediump> call(vecType<float, mediump> const & Min, vecType<float, mediump> const & Max)
GLM_FUNC_QUALIFIER static vecType<float, mediump> call(vecType<float, mediump> const & Min, vecType<float, mediump> const & Max) GLM_NOEXCEPT
{
return vecType<float, mediump>(compute_rand<uint16, mediump, vecType>::call()) / static_cast<float>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
}
@ -223,7 +223,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<float, highp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<float, highp> call(vecType<float, highp> const & Min, vecType<float, highp> const & Max)
GLM_FUNC_QUALIFIER static vecType<float, highp> call(vecType<float, highp> const & Min, vecType<float, highp> const & Max) GLM_NOEXCEPT
{
return vecType<float, highp>(compute_rand<uint32, highp, vecType>::call()) / static_cast<float>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
}
@ -232,7 +232,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<double, lowp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<double, lowp> call(vecType<double, lowp> const & Min, vecType<double, lowp> const & Max)
GLM_FUNC_QUALIFIER static vecType<double, lowp> call(vecType<double, lowp> const & Min, vecType<double, lowp> const & Max) GLM_NOEXCEPT
{
return vecType<double, lowp>(compute_rand<uint16, lowp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint16>::max()) * (Max - Min) + Min;
}
@ -241,7 +241,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<double, mediump, vecType>
{
GLM_FUNC_QUALIFIER static vecType<double, mediump> call(vecType<double, mediump> const & Min, vecType<double, mediump> const & Max)
GLM_FUNC_QUALIFIER static vecType<double, mediump> call(vecType<double, mediump> const & Min, vecType<double, mediump> const & Max) GLM_NOEXCEPT
{
return vecType<double, mediump>(compute_rand<uint32, mediump, vecType>::call()) / static_cast<double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
}
@ -250,7 +250,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<double, highp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<double, highp> call(vecType<double, highp> const & Min, vecType<double, highp> const & Max)
GLM_FUNC_QUALIFIER static vecType<double, highp> call(vecType<double, highp> const & Min, vecType<double, highp> const & Max) GLM_NOEXCEPT
{
return vecType<double, highp>(compute_rand<uint64, highp, vecType>::call()) / static_cast<double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
}
@ -259,7 +259,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<long double, lowp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<long double, lowp> call(vecType<long double, lowp> const & Min, vecType<long double, lowp> const & Max)
GLM_FUNC_QUALIFIER static vecType<long double, lowp> call(vecType<long double, lowp> const & Min, vecType<long double, lowp> const & Max) GLM_NOEXCEPT
{
return vecType<long double, lowp>(compute_rand<uint32, lowp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
}
@ -268,7 +268,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<long double, mediump, vecType>
{
GLM_FUNC_QUALIFIER static vecType<long double, mediump> call(vecType<long double, mediump> const & Min, vecType<long double, mediump> const & Max)
GLM_FUNC_QUALIFIER static vecType<long double, mediump> call(vecType<long double, mediump> const & Min, vecType<long double, mediump> const & Max) GLM_NOEXCEPT
{
return vecType<long double, mediump>(compute_rand<uint64, mediump, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
}
@ -277,7 +277,7 @@ namespace detail
template <template <class, precision> class vecType>
struct compute_linearRand<long double, highp, vecType>
{
GLM_FUNC_QUALIFIER static vecType<long double, highp> call(vecType<long double, highp> const & Min, vecType<long double, highp> const & Max)
GLM_FUNC_QUALIFIER static vecType<long double, highp> call(vecType<long double, highp> const & Min, vecType<long double, highp> const & Max) GLM_NOEXCEPT
{
return vecType<long double, highp>(compute_rand<uint64, highp, vecType>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
}
@ -285,7 +285,7 @@ namespace detail
}//namespace detail
template <typename genType>
GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max)
GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max) GLM_NOEXCEPT
{
return detail::compute_linearRand<genType, highp, tvec1>::call(
tvec1<genType, highp>(Min),
@ -293,13 +293,13 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> linearRand(vecType<T, P> const & Min, vecType<T, P> const & Max)
GLM_FUNC_QUALIFIER vecType<T, P> linearRand(vecType<T, P> const & Min, vecType<T, P> const & Max) GLM_NOEXCEPT
{
return detail::compute_linearRand<T, P, vecType>::call(Min, Max);
}
template <typename genType>
GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation)
GLM_FUNC_QUALIFIER genType gaussRand(genType Mean, genType Deviation) GLM_NOEXCEPT
{
genType w, x1, x2;
@ -315,13 +315,13 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> gaussRand(vecType<T, P> const & Mean, vecType<T, P> const & Deviation)
GLM_FUNC_QUALIFIER vecType<T, P> gaussRand(vecType<T, P> const & Mean, vecType<T, P> const & Deviation) GLM_NOEXCEPT
{
return detail::functor2<T, P, vecType>::call(gaussRand, Mean, Deviation);
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand(T Radius)
GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand(T Radius) GLM_NOEXCEPT
{
tvec2<T, defaultp> Result(T(0));
T LenRadius(T(0));
@ -339,7 +339,7 @@ namespace detail
}
template <typename T>
GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand(T Radius)
GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand(T Radius) GLM_NOEXCEPT
{
tvec3<T, defaultp> Result(T(0));
T LenRadius(T(0));
@ -356,15 +356,16 @@ namespace detail
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand(T Radius)
GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand(T Radius) GLM_NOEXCEPT
{
T a = linearRand(T(0), T(6.283185307179586476925286766559f));
return tvec2<T, defaultp>(cos(a), sin(a)) * Radius;
}
template <typename T>
GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand(T Radius)
GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand(T Radius) GLM_NOEXCEPT
{
T z = linearRand(T(-1), T(1));
T a = linearRand(T(0), T(6.283185307179586476925286766559f));

24
glm/gtc/reciprocal.hpp
View File

@ -58,75 +58,75 @@ namespace glm
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType sec(genType const & angle);
GLM_FUNC_DECL genType sec(genType const & angle) GLM_NOEXCEPT;
/// Cosecant function.
/// hypotenuse / opposite or 1 / sin(x)
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType csc(genType const & angle);
GLM_FUNC_DECL genType csc(genType const & angle) GLM_NOEXCEPT;
/// Cotangent function.
/// adjacent / opposite or 1 / tan(x)
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType cot(genType const & angle);
GLM_FUNC_DECL genType cot(genType const & angle) GLM_NOEXCEPT;
/// Inverse secant function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType asec(genType const & x);
GLM_FUNC_DECL genType asec(genType const & x) GLM_NOEXCEPT;
/// Inverse cosecant function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acsc(genType const & x);
GLM_FUNC_DECL genType acsc(genType const & x) GLM_NOEXCEPT;
/// Inverse cotangent function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acot(genType const & x);
GLM_FUNC_DECL genType acot(genType const & x) GLM_NOEXCEPT;
/// Secant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType sech(genType const & angle);
GLM_FUNC_DECL genType sech(genType const & angle) GLM_NOEXCEPT;
/// Cosecant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType csch(genType const & angle);
GLM_FUNC_DECL genType csch(genType const & angle) GLM_NOEXCEPT;
/// Cotangent hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType coth(genType const & angle);
GLM_FUNC_DECL genType coth(genType const & angle) GLM_NOEXCEPT;
/// Inverse secant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType asech(genType const & x);
GLM_FUNC_DECL genType asech(genType const & x) GLM_NOEXCEPT;
/// Inverse cosecant hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acsch(genType const & x);
GLM_FUNC_DECL genType acsch(genType const & x) GLM_NOEXCEPT;
/// Inverse cotangent hyperbolic function.
///
/// @see gtc_reciprocal
template <typename genType>
GLM_FUNC_DECL genType acoth(genType const & x);
GLM_FUNC_DECL genType acoth(genType const & x) GLM_NOEXCEPT;
/// @}
}//namespace glm

48
glm/gtc/reciprocal.inl
View File

@ -37,14 +37,14 @@ namespace glm
{
// sec
template <typename genType>
GLM_FUNC_QUALIFIER genType sec(genType angle)
GLM_FUNC_QUALIFIER genType sec(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sec' only accept floating-point values");
return genType(1) / glm::cos(angle);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> sec(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> sec(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sec' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(sec, x);
@ -52,14 +52,14 @@ namespace glm
// csc
template <typename genType>
GLM_FUNC_QUALIFIER genType csc(genType angle)
GLM_FUNC_QUALIFIER genType csc(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csc' only accept floating-point values");
return genType(1) / glm::sin(angle);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> csc(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> csc(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csc' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(csc, x);
@ -67,7 +67,7 @@ namespace glm
// cot
template <typename genType>
GLM_FUNC_QUALIFIER genType cot(genType angle)
GLM_FUNC_QUALIFIER genType cot(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'cot' only accept floating-point values");
@ -76,7 +76,7 @@ namespace glm
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> cot(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> cot(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cot' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(cot, x);
@ -84,14 +84,14 @@ namespace glm
// asec
template <typename genType>
GLM_FUNC_QUALIFIER genType asec(genType x)
GLM_FUNC_QUALIFIER genType asec(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asec' only accept floating-point values");
return acos(genType(1) / x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> asec(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> asec(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asec' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(asec, x);
@ -99,14 +99,14 @@ namespace glm
// acsc
template <typename genType>
GLM_FUNC_QUALIFIER genType acsc(genType x)
GLM_FUNC_QUALIFIER genType acsc(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsc' only accept floating-point values");
return asin(genType(1) / x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> acsc(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> acsc(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsc' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(acsc, x);
@ -114,7 +114,7 @@ namespace glm
// acot
template <typename genType>
GLM_FUNC_QUALIFIER genType acot(genType x)
GLM_FUNC_QUALIFIER genType acot(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acot' only accept floating-point values");
@ -123,7 +123,7 @@ namespace glm
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> acot(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> acot(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acot' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(acot, x);
@ -131,14 +131,14 @@ namespace glm
// sech
template <typename genType>
GLM_FUNC_QUALIFIER genType sech(genType angle)
GLM_FUNC_QUALIFIER genType sech(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'sech' only accept floating-point values");
return genType(1) / glm::cosh(angle);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> sech(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> sech(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sech' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(sech, x);
@ -146,14 +146,14 @@ namespace glm
// csch
template <typename genType>
GLM_FUNC_QUALIFIER genType csch(genType angle)
GLM_FUNC_QUALIFIER genType csch(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'csch' only accept floating-point values");
return genType(1) / glm::sinh(angle);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> csch(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> csch(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csch' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(csch, x);
@ -161,14 +161,14 @@ namespace glm
// coth
template <typename genType>
GLM_FUNC_QUALIFIER genType coth(genType angle)
GLM_FUNC_QUALIFIER genType coth(genType angle) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'coth' only accept floating-point values");
return glm::cosh(angle) / glm::sinh(angle);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> coth(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> coth(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'coth' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(coth, x);
@ -176,14 +176,14 @@ namespace glm
// asech
template <typename genType>
GLM_FUNC_QUALIFIER genType asech(genType x)
GLM_FUNC_QUALIFIER genType asech(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asech' only accept floating-point values");
return acosh(genType(1) / x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> asech(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> asech(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asech' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(asech, x);
@ -191,14 +191,14 @@ namespace glm
// acsch
template <typename genType>
GLM_FUNC_QUALIFIER genType acsch(genType x)
GLM_FUNC_QUALIFIER genType acsch(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acsch' only accept floating-point values");
return acsch(genType(1) / x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> acsch(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> acsch(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsch' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(acsch, x);
@ -206,14 +206,14 @@ namespace glm
// acoth
template <typename genType>
GLM_FUNC_QUALIFIER genType acoth(genType x)
GLM_FUNC_QUALIFIER genType acoth(genType x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acoth' only accept floating-point values");
return atanh(genType(1) / x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> acoth(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> acoth(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acoth' only accept floating-point inputs");
return detail::functor1<T, T, P, vecType>::call(acoth, x);

34
glm/gtc/round.hpp
View File

@ -63,71 +63,71 @@ namespace glm
///
/// @see gtc_round
template <typename genIUType>
GLM_FUNC_DECL bool isPowerOfTwo(genIUType Value);
GLM_FUNC_DECL bool isPowerOfTwo(genIUType Value) GLM_NOEXCEPT;
/// Return true if the value is a power of two number.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> isPowerOfTwo(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<bool, P> isPowerOfTwo(vecType<T, P> const & value) GLM_NOEXCEPT;
/// Return the power of two number which value is just higher the input value,
/// round up to a power of two.
///
/// @see gtc_round
template <typename genIUType>
GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value);
GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value) GLM_NOEXCEPT;
/// Return the power of two number which value is just higher the input value,
/// round up to a power of two.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & value) GLM_NOEXCEPT;
/// Return the power of two number which value is just lower the input value,
/// round down to a power of two.
///
/// @see gtc_round
template <typename genIUType>
GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value);
GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value) GLM_NOEXCEPT;
/// Return the power of two number which value is just lower the input value,
/// round down to a power of two.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> floorPowerOfTwo(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> floorPowerOfTwo(vecType<T, P> const & value) GLM_NOEXCEPT;
/// Return the power of two number which value is the closet to the input value.
///
/// @see gtc_round
template <typename genIUType>
GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value);
GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value) GLM_NOEXCEPT;
/// Return the power of two number which value is the closet to the input value.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value) GLM_NOEXCEPT;
/// Return true if the 'Value' is a multiple of 'Multiple'.
///
/// @see gtc_round
template <typename genIUType>
GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple);
GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple) GLM_NOEXCEPT;
/// Return true if the 'Value' is a multiple of 'Multiple'.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple);
GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple) GLM_NOEXCEPT;
/// Return true if the 'Value' is a multiple of 'Multiple'.
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple);
GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple) GLM_NOEXCEPT;
/// Higher multiple number of Source.
///
@ -137,7 +137,7 @@ namespace glm
///
/// @see gtc_round
template <typename genType>
GLM_FUNC_DECL genType ceilMultiple(genType Source, genType Multiple);
GLM_FUNC_DECL genType ceilMultiple(genType Source, genType Multiple) GLM_NOEXCEPT;
/// Higher multiple number of Source.
///
@ -147,7 +147,7 @@ namespace glm
///
/// @see gtc_round
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple);
GLM_FUNC_DECL vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple) GLM_NOEXCEPT;
/// Lower multiple number of Source.
///
@ -159,7 +159,7 @@ namespace glm
template <typename genType>
GLM_FUNC_DECL genType floorMultiple(
genType Source,
genType Multiple);
genType Multiple) GLM_NOEXCEPT;
/// Lower multiple number of Source.
///
@ -171,7 +171,7 @@ namespace glm
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> floorMultiple(
vecType<T, P> const & Source,
vecType<T, P> const & Multiple);
vecType<T, P> const & Multiple) GLM_NOEXCEPT;
/// Lower multiple number of Source.
///
@ -183,7 +183,7 @@ namespace glm
template <typename genType>
GLM_FUNC_DECL genType roundMultiple(
genType Source,
genType Multiple);
genType Multiple) GLM_NOEXCEPT;
/// Lower multiple number of Source.
///
@ -195,7 +195,7 @@ namespace glm
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> roundMultiple(
vecType<T, P> const & Source,
vecType<T, P> const & Multiple);
vecType<T, P> const & Multiple) GLM_NOEXCEPT;
/// @}
} //namespace glm

60
glm/gtc/round.inl
View File

@ -37,7 +37,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType, bool compute = false>
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T) GLM_NOEXCEPT
{
return v;
}
@ -46,7 +46,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType>
struct compute_ceilShift<T, P, vecType, true>
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Shift)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Shift) GLM_NOEXCEPT
{
return v | (v >> Shift);
}
@ -55,7 +55,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType, bool isSigned = true>
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
@ -77,7 +77,7 @@ namespace detail
template <typename T, precision P, template <typename, precision> class vecType>
struct compute_ceilPowerOfTwo<T, P, vecType, false>
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x) GLM_NOEXCEPT
{
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
@ -101,7 +101,7 @@ namespace detail
struct compute_ceilMultiple<true, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source > genType(0))
{
@ -117,7 +117,7 @@ namespace detail
struct compute_ceilMultiple<false, false>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
genType Tmp = Source - genType(1);
return Tmp + (Multiple - (Tmp % Multiple));
@ -128,7 +128,7 @@ namespace detail
struct compute_ceilMultiple<false, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source > genType(0))
{
@ -147,7 +147,7 @@ namespace detail
struct compute_floorMultiple<true, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - std::fmod(Source, Multiple);
@ -163,7 +163,7 @@ namespace detail
struct compute_floorMultiple<false, false>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - Source % Multiple;
@ -179,7 +179,7 @@ namespace detail
struct compute_floorMultiple<false, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - Source % Multiple;
@ -198,7 +198,7 @@ namespace detail
struct compute_roundMultiple<true, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - std::fmod(Source, Multiple);
@ -214,7 +214,7 @@ namespace detail
struct compute_roundMultiple<false, false>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - Source % Multiple;
@ -230,7 +230,7 @@ namespace detail
struct compute_roundMultiple<false, true>
{
template <typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) GLM_NOEXCEPT
{
if(Source >= genType(0))
return Source - Source % Multiple;
@ -247,14 +247,14 @@ namespace detail
// isPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value) GLM_NOEXCEPT
{
genType const Result = glm::abs(Value);
return !(Result & (Result - 1));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<bool, P> isPowerOfTwo(vecType<T, P> const & Value)
GLM_FUNC_QUALIFIER vecType<bool, P> isPowerOfTwo(vecType<T, P> const & Value) GLM_NOEXCEPT
{
vecType<T, P> const Result(abs(Value));
return equal(Result & (Result - 1), vecType<T, P>(0));
@ -264,13 +264,13 @@ namespace detail
// ceilPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value) GLM_NOEXCEPT
{
return detail::compute_ceilPowerOfTwo<genType, defaultp, tvec1, std::numeric_limits<genType>::is_signed>::call(tvec1<genType, defaultp>(value)).x;
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & v) GLM_NOEXCEPT
{
return detail::compute_ceilPowerOfTwo<T, P, vecType, std::numeric_limits<T>::is_signed>::call(v);
}
@ -279,13 +279,13 @@ namespace detail
// floorPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value) GLM_NOEXCEPT
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> floorPowerOfTwo(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> floorPowerOfTwo(vecType<T, P> const & v) GLM_NOEXCEPT
{
return detail::functor1<T, T, P, vecType>::call(floorPowerOfTwo, v);
}
@ -294,7 +294,7 @@ namespace detail
// roundPowerOfTwo
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value) GLM_NOEXCEPT
{
if(isPowerOfTwo(value))
return value;
@ -305,7 +305,7 @@ namespace detail
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> roundPowerOfTwo(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> roundPowerOfTwo(vecType<T, P> const & v) GLM_NOEXCEPT
{
return detail::functor1<T, T, P, vecType>::call(roundPowerOfTwo, v);
}
@ -314,19 +314,19 @@ namespace detail
// isMultiple
template <typename genType>
GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple) GLM_NOEXCEPT
{
return isMultiple(tvec1<genType>(Value), tvec1<genType>(Multiple)).x;
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple)
GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple) GLM_NOEXCEPT
{
return (Value % Multiple) == vecType<T, P>(0);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple)
GLM_FUNC_QUALIFIER vecType<bool, P> isMultiple(vecType<T, P> const & Value, vecType<T, P> const & Multiple) GLM_NOEXCEPT
{
return (Value % Multiple) == vecType<T, P>(0);
}
@ -335,13 +335,13 @@ namespace detail
// ceilMultiple
template <typename genType>
GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple) GLM_NOEXCEPT
{
return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
GLM_FUNC_QUALIFIER vecType<T, P> ceilMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple) GLM_NOEXCEPT
{
return detail::functor2<T, P, vecType>::call(ceilMultiple, Source, Multiple);
}
@ -350,13 +350,13 @@ namespace detail
// floorMultiple
template <typename genType>
GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple) GLM_NOEXCEPT
{
return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> floorMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
GLM_FUNC_QUALIFIER vecType<T, P> floorMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple) GLM_NOEXCEPT
{
return detail::functor2<T, P, vecType>::call(floorMultiple, Source, Multiple);
}
@ -365,13 +365,13 @@ namespace detail
// roundMultiple
template <typename genType>
GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple) GLM_NOEXCEPT
{
return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> roundMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
GLM_FUNC_QUALIFIER vecType<T, P> roundMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple) GLM_NOEXCEPT
{
return detail::functor2<T, P, vecType>::call(roundMultiple, Source, Multiple);
}

34
glm/gtc/type_ptr.hpp
View File

@ -90,87 +90,87 @@ namespace glm
/// Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename genType>
GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const & vec);
GLM_FUNC_DECL typename genType::value_type const * value_ptr(genType const & vec) GLM_NOEXCEPT;
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr);
GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr) GLM_NOEXCEPT;
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr);
GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr) GLM_NOEXCEPT;
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr);
GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(T const * const ptr);
GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr);
GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr);
GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr) GLM_NOEXCEPT;
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr);
GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr) GLM_NOEXCEPT;
/// Build a quaternion from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_DECL tquat<T, defaultp> make_quat(T const * const ptr);
GLM_FUNC_DECL tquat<T, defaultp> make_quat(T const * const ptr) GLM_NOEXCEPT;
/// @}
}//namespace glm

84
glm/gtc/type_ptr.inl
View File

@ -43,7 +43,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tvec2<T, P> const & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -54,7 +54,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tvec2<T, P> & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -65,7 +65,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tvec3<T, P> const & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -76,7 +76,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tvec3<T, P> & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -87,7 +87,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tvec4<T, P> const & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -98,7 +98,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tvec4<T, P> & vec
)
) GLM_NOEXCEPT
{
return &(vec.x);
}
@ -109,7 +109,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat2x2<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -120,7 +120,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat2x2<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -131,7 +131,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat3x3<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -142,7 +142,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat3x3<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -153,7 +153,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat4x4<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -164,7 +164,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat4x4<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -175,7 +175,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat2x3<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -186,7 +186,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat2x3<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -197,7 +197,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat3x2<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -208,7 +208,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat3x2<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -219,7 +219,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat2x4<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -230,7 +230,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat2x4<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -241,7 +241,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat4x2<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -252,7 +252,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat4x2<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -263,7 +263,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat3x4<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -274,7 +274,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tmat3x4<T, P> & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -285,7 +285,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tmat4x3<T, P> const & mat
)
) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -293,7 +293,7 @@ namespace glm
/// Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
GLM_FUNC_QUALIFIER T * value_ptr(tmat4x3<T, P> & mat)
GLM_FUNC_QUALIFIER T * value_ptr(tmat4x3<T, P> & mat) GLM_NOEXCEPT
{
return &(mat[0].x);
}
@ -304,7 +304,7 @@ namespace glm
GLM_FUNC_QUALIFIER T const * value_ptr
(
tquat<T, P> const & q
)
) GLM_NOEXCEPT
{
return &(q[0]);
}
@ -315,7 +315,7 @@ namespace glm
GLM_FUNC_QUALIFIER T * value_ptr
(
tquat<T, P> & q
)
) GLM_NOEXCEPT
{
return &(q[0]);
}
@ -323,7 +323,7 @@ namespace glm
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tvec2<T, defaultp> make_vec2(T const * const ptr)
GLM_FUNC_QUALIFIER tvec2<T, defaultp> make_vec2(T const * const ptr) GLM_NOEXCEPT
{
tvec2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec2<T, defaultp>));
@ -333,7 +333,7 @@ namespace glm
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tvec3<T, defaultp> make_vec3(T const * const ptr)
GLM_FUNC_QUALIFIER tvec3<T, defaultp> make_vec3(T const * const ptr) GLM_NOEXCEPT
{
tvec3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec3<T, defaultp>));
@ -343,7 +343,7 @@ namespace glm
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tvec4<T, defaultp> make_vec4(T const * const ptr)
GLM_FUNC_QUALIFIER tvec4<T, defaultp> make_vec4(T const * const ptr) GLM_NOEXCEPT
{
tvec4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tvec4<T, defaultp>));
@ -353,7 +353,7 @@ namespace glm
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2x2(T const * const ptr) GLM_NOEXCEPT
{
tmat2x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x2<T, defaultp>));
@ -363,7 +363,7 @@ namespace glm
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x3<T, defaultp> make_mat2x3(T const * const ptr) GLM_NOEXCEPT
{
tmat2x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x3<T, defaultp>));
@ -373,7 +373,7 @@ namespace glm
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x4<T, defaultp> make_mat2x4(T const * const ptr) GLM_NOEXCEPT
{
tmat2x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat2x4<T, defaultp>));
@ -383,7 +383,7 @@ namespace glm
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x2<T, defaultp> make_mat3x2(T const * const ptr) GLM_NOEXCEPT
{
tmat3x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x2<T, defaultp>));
@ -393,7 +393,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3x3(T const * const ptr) GLM_NOEXCEPT
{
tmat3x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x3<T, defaultp>));
@ -403,7 +403,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x4<T, defaultp> make_mat3x4(T const * const ptr) GLM_NOEXCEPT
{
tmat3x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat3x4<T, defaultp>));
@ -413,7 +413,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x2<T, defaultp> make_mat4x2(T const * const ptr) GLM_NOEXCEPT
{
tmat4x2<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x2<T, defaultp>));
@ -423,7 +423,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x3<T, defaultp> make_mat4x3(T const * const ptr) GLM_NOEXCEPT
{
tmat4x3<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x3<T, defaultp>));
@ -433,7 +433,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4x4(T const * const ptr) GLM_NOEXCEPT
{
tmat4x4<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tmat4x4<T, defaultp>));
@ -443,7 +443,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2(T const * const ptr)
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2(T const * const ptr) GLM_NOEXCEPT
{
return make_mat2x2(ptr);
}
@ -451,7 +451,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3(T const * const ptr)
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3(T const * const ptr) GLM_NOEXCEPT
{
return make_mat3x3(ptr);
}
@ -459,7 +459,7 @@ namespace glm
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4(T const * const ptr)
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4(T const * const ptr) GLM_NOEXCEPT
{
return make_mat4x4(ptr);
}
@ -467,7 +467,7 @@ namespace glm
//! Build a quaternion from a pointer.
/// @see gtc_type_ptr
template <typename T>
GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const * const ptr)
GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const * const ptr) GLM_NOEXCEPT
{
tquat<T, defaultp> Result;
memcpy(value_ptr(Result), ptr, sizeof(tquat<T, defaultp>));

12
glm/gtc/ulp.hpp
View File

@ -59,32 +59,32 @@ namespace glm
/// Return the next ULP value(s) after the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType next_float(genType const & x);
GLM_FUNC_DECL genType next_float(genType const & x) GLM_NOEXCEPT;
/// Return the previous ULP value(s) before the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType prev_float(genType const & x);
GLM_FUNC_DECL genType prev_float(genType const & x) GLM_NOEXCEPT;
/// Return the value(s) ULP distance after the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance);
GLM_FUNC_DECL genType next_float(genType const & x, uint const & Distance) GLM_NOEXCEPT;
/// Return the value(s) ULP distance before the input value(s).
/// @see gtc_ulp
template <typename genType>
GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance);
GLM_FUNC_DECL genType prev_float(genType const & x, uint const & Distance) GLM_NOEXCEPT;
/// Return the distance in the number of ULP between 2 scalars.
/// @see gtc_ulp
template <typename T>
GLM_FUNC_DECL uint float_distance(T const & x, T const & y);
GLM_FUNC_DECL uint float_distance(T const & x, T const & y) GLM_NOEXCEPT;
/// Return the distance in the number of ULP between 2 vectors.
/// @see gtc_ulp
template<typename T, template<typename> class vecType>
GLM_FUNC_DECL vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
GLM_FUNC_DECL vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y) GLM_NOEXCEPT;
/// @}
}// namespace glm

28
glm/gtc/ulp.inl
View File

@ -97,7 +97,7 @@ typedef union
namespace glm{
namespace detail
{
GLM_FUNC_QUALIFIER float nextafterf(float x, float y)
GLM_FUNC_QUALIFIER float nextafterf(float x, float y) GLM_NOEXCEPT
{
volatile float t;
glm::detail::int32 hx, hy, ix, iy;
@ -142,7 +142,7 @@ namespace detail
return x;
}
GLM_FUNC_QUALIFIER double nextafter(double x, double y)
GLM_FUNC_QUALIFIER double nextafter(double x, double y) GLM_NOEXCEPT
{
volatile double t;
glm::detail::int32 hx, hy, ix, iy;
@ -201,7 +201,7 @@ namespace detail
namespace glm
{
template <>
GLM_FUNC_QUALIFIER float next_float(float const & x)
GLM_FUNC_QUALIFIER float next_float(float const & x) GLM_NOEXCEPT
{
# if GLM_HAS_CXX11_STL
return std::nextafter(x, std::numeric_limits<float>::max());
@ -215,7 +215,7 @@ namespace glm
}
template <>
GLM_FUNC_QUALIFIER double next_float(double const & x)
GLM_FUNC_QUALIFIER double next_float(double const & x) GLM_NOEXCEPT
{
# if GLM_HAS_CXX11_STL
return std::nextafter(x, std::numeric_limits<double>::max());
@ -229,7 +229,7 @@ namespace glm
}
template<typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x) GLM_NOEXCEPT
{
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
@ -237,7 +237,7 @@ namespace glm
return Result;
}
GLM_FUNC_QUALIFIER float prev_float(float const & x)
GLM_FUNC_QUALIFIER float prev_float(float const & x) GLM_NOEXCEPT
{
# if GLM_HAS_CXX11_STL
return std::nextafter(x, std::numeric_limits<float>::min());
@ -250,7 +250,7 @@ namespace glm
# endif
}
GLM_FUNC_QUALIFIER double prev_float(double const & x)
GLM_FUNC_QUALIFIER double prev_float(double const & x) GLM_NOEXCEPT
{
# if GLM_HAS_CXX11_STL
return std::nextafter(x, std::numeric_limits<double>::min());
@ -264,7 +264,7 @@ namespace glm
}
template<typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x)
GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x) GLM_NOEXCEPT
{
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
@ -273,7 +273,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER T next_float(T const & x, uint const & ulps)
GLM_FUNC_QUALIFIER T next_float(T const & x, uint const & ulps) GLM_NOEXCEPT
{
T temp = x;
for(uint i = 0; i < ulps; ++i)
@ -282,7 +282,7 @@ namespace glm
}
template<typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x, vecType<uint, P> const & ulps)
GLM_FUNC_QUALIFIER vecType<T, P> next_float(vecType<T, P> const & x, vecType<uint, P> const & ulps) GLM_NOEXCEPT
{
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
@ -291,7 +291,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER T prev_float(T const & x, uint const & ulps)
GLM_FUNC_QUALIFIER T prev_float(T const & x, uint const & ulps) GLM_NOEXCEPT
{
T temp = x;
for(uint i = 0; i < ulps; ++i)
@ -300,7 +300,7 @@ namespace glm
}
template<typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x, vecType<uint, P> const & ulps)
GLM_FUNC_QUALIFIER vecType<T, P> prev_float(vecType<T, P> const & x, vecType<uint, P> const & ulps) GLM_NOEXCEPT
{
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
@ -309,7 +309,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER uint float_distance(T const & x, T const & y)
GLM_FUNC_QUALIFIER uint float_distance(T const & x, T const & y) GLM_NOEXCEPT
{
uint ulp = 0;
@ -340,7 +340,7 @@ namespace glm
}
template<typename T, precision P, template<typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<uint, P> float_distance(vecType<T, P> const & x, vecType<T, P> const & y)
GLM_FUNC_QUALIFIER vecType<uint, P> float_distance(vecType<T, P> const & x, vecType<T, P> const & y) GLM_NOEXCEPT
{
vecType<uint, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)