mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-25 09:44:02 +00:00
743 lines
16 KiB
C++
743 lines
16 KiB
C++
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Created : 2007-03-14
|
|
// Updated : 2008-11-14
|
|
// Licence : This source is under MIT License
|
|
// File : glm/gtx/bit.inl
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "../core/_detail.hpp"
|
|
|
|
namespace glm{
|
|
namespace gtx{
|
|
namespace bit{
|
|
|
|
template <typename genIType>
|
|
GLM_FUNC_QUALIFIER genIType mask
|
|
(
|
|
genIType const & count
|
|
)
|
|
{
|
|
return ((genIType(1) << (count)) - genIType(1));
|
|
}
|
|
|
|
template <typename valIType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valIType> mask
|
|
(
|
|
detail::tvec2<valIType> const & count
|
|
)
|
|
{
|
|
return detail::tvec2<valIType>(
|
|
mask(count[0]),
|
|
mask(count[1]));
|
|
}
|
|
|
|
template <typename valIType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valIType> mask
|
|
(
|
|
detail::tvec3<valIType> const & count
|
|
)
|
|
{
|
|
return detail::tvec3<valIType>(
|
|
mask(count[0]),
|
|
mask(count[1]),
|
|
mask(count[2]));
|
|
}
|
|
|
|
template <typename valIType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valIType> mask
|
|
(
|
|
detail::tvec4<valIType> const & count
|
|
)
|
|
{
|
|
return detail::tvec4<valIType>(
|
|
mask(count[0]),
|
|
mask(count[1]),
|
|
mask(count[2]),
|
|
mask(count[3]));
|
|
}
|
|
|
|
// extractField
|
|
template <typename genIType>
|
|
GLM_FUNC_QUALIFIER genIType extractField
|
|
(
|
|
gtc::half_float::half const & value,
|
|
genIType const & first,
|
|
genIType const & count
|
|
)
|
|
{
|
|
assert(first + count < sizeof(gtc::half_float::half));
|
|
return (value._data() << first) >> ((sizeof(gtc::half_float::half) << 3) - count);
|
|
}
|
|
|
|
template <typename genIType>
|
|
GLM_FUNC_QUALIFIER genIType extractField
|
|
(
|
|
float const & value,
|
|
genIType const & first,
|
|
genIType const & count
|
|
)
|
|
{
|
|
assert(first + count < sizeof(float));
|
|
return (detail::uif32(value).i << first) >> ((sizeof(float) << 3) - count);
|
|
}
|
|
|
|
template <typename genIType>
|
|
GLM_FUNC_QUALIFIER genIType extractField
|
|
(
|
|
double const & value,
|
|
genIType const & first,
|
|
genIType const & count
|
|
)
|
|
{
|
|
assert(first + count < sizeof(double));
|
|
return (detail::uif64(value).i << first) >> ((sizeof(double) << genIType(3)) - count);
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER genIUType extractField
|
|
(
|
|
genIUType const & Value,
|
|
sizeType const & First,
|
|
sizeType const & Count
|
|
)
|
|
{
|
|
sizeType GenSize = sizeof(genIUType) << 3;
|
|
|
|
assert(First + Count <= GenSize);
|
|
|
|
genIUType ShiftLeft = Count ? Value << (GenSize - (Count + First)) : 0;
|
|
genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Count);
|
|
|
|
return ShiftBack;
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
|
|
(
|
|
detail::tvec2<genIUType> const & value,
|
|
sizeType const & first,
|
|
sizeType const & count
|
|
)
|
|
{
|
|
return detail::tvec2<genIUType>(
|
|
extractField(value[0], first, count),
|
|
extractField(value[1], first, count));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
|
|
(
|
|
detail::tvec3<genIUType> const & value,
|
|
sizeType const & first,
|
|
sizeType const & count
|
|
)
|
|
{
|
|
return detail::tvec3<genIUType>(
|
|
extractField(value[0], first, count),
|
|
extractField(value[1], first, count),
|
|
extractField(value[2], first, count));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
|
|
(
|
|
detail::tvec4<genIUType> const & value,
|
|
sizeType const & first,
|
|
sizeType const & count
|
|
)
|
|
{
|
|
return detail::tvec4<genIUType>(
|
|
extractField(value[0], first, count),
|
|
extractField(value[1], first, count),
|
|
extractField(value[2], first, count),
|
|
extractField(value[3], first, count));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
|
|
(
|
|
detail::tvec2<genIUType> const & value,
|
|
detail::tvec2<sizeType> const & first,
|
|
detail::tvec2<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec2<genIUType>(
|
|
extractField(value[0], first[0], count[0]),
|
|
extractField(value[1], first[1], count[1]));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
|
|
(
|
|
detail::tvec3<genIUType> const & value,
|
|
detail::tvec3<sizeType> const & first,
|
|
detail::tvec3<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec3<genIUType>(
|
|
extractField(value[0], first[0], count[0]),
|
|
extractField(value[1], first[1], count[1]),
|
|
extractField(value[2], first[2], count[2]));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
|
|
(
|
|
detail::tvec4<genIUType> const & value,
|
|
detail::tvec4<sizeType> const & first,
|
|
detail::tvec4<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec4<genIUType>(
|
|
extractField(value[0], first[0], count[0]),
|
|
extractField(value[1], first[1], count[1]),
|
|
extractField(value[2], first[2], count[2]),
|
|
extractField(value[3], first[3], count[3]));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
|
|
(
|
|
genIUType const & value,
|
|
detail::tvec2<sizeType> const & first,
|
|
detail::tvec2<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec2<genIUType>(
|
|
extractField(value, first[0], count[0]),
|
|
extractField(value, first[1], count[1]));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
|
|
(
|
|
genIUType const & value,
|
|
detail::tvec3<sizeType> const & first,
|
|
detail::tvec3<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec3<genIUType>(
|
|
extractField(value, first[0], count[0]),
|
|
extractField(value, first[1], count[1]),
|
|
extractField(value, first[2], count[2]));
|
|
}
|
|
|
|
template <typename genIUType, typename sizeType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
|
|
(
|
|
genIUType const & value,
|
|
detail::tvec4<sizeType> const & first,
|
|
detail::tvec4<sizeType> const & count
|
|
)
|
|
{
|
|
return detail::tvec4<genIUType>(
|
|
extractField(value, first[0], count[0]),
|
|
extractField(value, first[1], count[1]),
|
|
extractField(value, first[2], count[2]),
|
|
extractField(value, first[3], count[3]));
|
|
}
|
|
|
|
// lowestBit
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER int lowestBit
|
|
(
|
|
genType const & Value
|
|
)
|
|
{
|
|
assert(Value != genType(0)); // not valid call
|
|
|
|
genType Bit;
|
|
for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
|
|
return Bit;
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<int> lowestBit
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<int>(
|
|
lowestBit(value[0]),
|
|
lowestBit(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<int> lowestBit
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<int>(
|
|
lowestBit(value[0]),
|
|
lowestBit(value[1]),
|
|
lowestBit(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<int> lowestBit
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<int>(
|
|
lowestBit(value[0]),
|
|
lowestBit(value[1]),
|
|
lowestBit(value[2]),
|
|
lowestBit(value[3]));
|
|
}
|
|
|
|
// highestBit
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER int highestBit
|
|
(
|
|
genType const & value
|
|
)
|
|
{
|
|
assert(value != genType(0)); // not valid call
|
|
|
|
genType bit = genType(-1);
|
|
for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
|
|
return bit;
|
|
}
|
|
|
|
//template <>
|
|
//GLM_FUNC_QUALIFIER int highestBit<int>
|
|
//(
|
|
// int value
|
|
//)
|
|
//{
|
|
// int bit = -1;
|
|
// for(int tmp = value; tmp; tmp >>= 1, ++bit);
|
|
// return bit;
|
|
//}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<int> highestBit
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<int>(
|
|
highestBit(value[0]),
|
|
highestBit(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<int> highestBit
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<int>(
|
|
highestBit(value[0]),
|
|
highestBit(value[1]),
|
|
highestBit(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<int> highestBit
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<int>(
|
|
highestBit(value[0]),
|
|
highestBit(value[1]),
|
|
highestBit(value[2]),
|
|
highestBit(value[3]));
|
|
}
|
|
|
|
// highestBitValue
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType highestBitValue
|
|
(
|
|
genType const & value
|
|
)
|
|
{
|
|
genType tmp = value;
|
|
genType result = genType(0);
|
|
while(tmp)
|
|
{
|
|
result = (tmp & (~tmp + 1)); // grab lowest bit
|
|
tmp &= ~result; // clear lowest bit
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<int> highestBitValue
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<int>(
|
|
highestBitValue(value[0]),
|
|
highestBitValue(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<int> highestBitValue
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<int>(
|
|
highestBitValue(value[0]),
|
|
highestBitValue(value[1]),
|
|
highestBitValue(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<int> highestBitValue
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<int>(
|
|
highestBitValue(value[0]),
|
|
highestBitValue(value[1]),
|
|
highestBitValue(value[2]),
|
|
highestBitValue(value[3]));
|
|
}
|
|
|
|
// isPowerOfTwo
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
|
|
{
|
|
//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
|
|
//return !(Value & (Value - 1));
|
|
|
|
// For old complier?
|
|
genType Result = Value;
|
|
if(std::numeric_limits<genType>::is_signed)
|
|
Result = abs(Result);
|
|
return !(Result & (Result - 1));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<bool> isPowerOfTwo
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<bool>(
|
|
isPowerOfTwo(value[0]),
|
|
isPowerOfTwo(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<bool> isPowerOfTwo
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<bool>(
|
|
isPowerOfTwo(value[0]),
|
|
isPowerOfTwo(value[1]),
|
|
isPowerOfTwo(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<bool> isPowerOfTwo
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<bool>(
|
|
isPowerOfTwo(value[0]),
|
|
isPowerOfTwo(value[1]),
|
|
isPowerOfTwo(value[2]),
|
|
isPowerOfTwo(value[3]));
|
|
}
|
|
|
|
// powerOfTwoAbove
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
|
|
{
|
|
return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoAbove
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
powerOfTwoAbove(value[0]),
|
|
powerOfTwoAbove(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoAbove
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
powerOfTwoAbove(value[0]),
|
|
powerOfTwoAbove(value[1]),
|
|
powerOfTwoAbove(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoAbove
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
powerOfTwoAbove(value[0]),
|
|
powerOfTwoAbove(value[1]),
|
|
powerOfTwoAbove(value[2]),
|
|
powerOfTwoAbove(value[3]));
|
|
}
|
|
|
|
// powerOfTwoBelow
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType powerOfTwoBelow
|
|
(
|
|
genType const & value
|
|
)
|
|
{
|
|
return isPowerOfTwo(value) ? value : highestBitValue(value);
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoBelow
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
powerOfTwoBelow(value[0]),
|
|
powerOfTwoBelow(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoBelow
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
powerOfTwoBelow(value[0]),
|
|
powerOfTwoBelow(value[1]),
|
|
powerOfTwoBelow(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoBelow
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
powerOfTwoBelow(value[0]),
|
|
powerOfTwoBelow(value[1]),
|
|
powerOfTwoBelow(value[2]),
|
|
powerOfTwoBelow(value[3]));
|
|
}
|
|
|
|
// powerOfTwoNearest
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType powerOfTwoNearest
|
|
(
|
|
genType const & value
|
|
)
|
|
{
|
|
if(isPowerOfTwo(value))
|
|
return value;
|
|
|
|
genType prev = highestBitValue(value);
|
|
genType next = prev << 1;
|
|
return (next - value) < (value - prev) ? next : prev;
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoNearest
|
|
(
|
|
detail::tvec2<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
powerOfTwoNearest(value[0]),
|
|
powerOfTwoNearest(value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoNearest
|
|
(
|
|
detail::tvec3<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
powerOfTwoNearest(value[0]),
|
|
powerOfTwoNearest(value[1]),
|
|
powerOfTwoNearest(value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoNearest
|
|
(
|
|
detail::tvec4<valType> const & value
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
powerOfTwoNearest(value[0]),
|
|
powerOfTwoNearest(value[1]),
|
|
powerOfTwoNearest(value[2]),
|
|
powerOfTwoNearest(value[3]));
|
|
}
|
|
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
|
|
{
|
|
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
|
|
|
|
genType Out = 0;
|
|
std::size_t BitSize = sizeof(genType) * 8;
|
|
for(std::size_t i = 0; i < BitSize; ++i)
|
|
if(In & (genType(1) << i))
|
|
Out |= genType(1) << (BitSize - 1 - i);
|
|
return Out;
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRevert
|
|
(
|
|
detail::tvec2<valType> const & Value
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
bitRevert(Value[0]),
|
|
bitRevert(Value[1]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRevert
|
|
(
|
|
detail::tvec3<valType> const & Value
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
bitRevert(Value[0]),
|
|
bitRevert(Value[1]),
|
|
bitRevert(Value[2]));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRevert
|
|
(
|
|
detail::tvec4<valType> const & Value
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
bitRevert(Value[0]),
|
|
bitRevert(Value[1]),
|
|
bitRevert(Value[2]),
|
|
bitRevert(Value[3]));
|
|
}
|
|
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
|
|
{
|
|
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
|
|
|
|
std::size_t BitSize = sizeof(genType) * 8;
|
|
return (In << Shift) | (In >> (BitSize - Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateRight
|
|
(
|
|
detail::tvec2<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
bitRotateRight(Value[0], Shift),
|
|
bitRotateRight(Value[1], Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateRight
|
|
(
|
|
detail::tvec3<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
bitRotateRight(Value[0], Shift),
|
|
bitRotateRight(Value[1], Shift),
|
|
bitRotateRight(Value[2], Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateRight
|
|
(
|
|
detail::tvec4<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
bitRotateRight(Value[0], Shift),
|
|
bitRotateRight(Value[1], Shift),
|
|
bitRotateRight(Value[2], Shift),
|
|
bitRotateRight(Value[3], Shift));
|
|
}
|
|
|
|
template <typename genType>
|
|
GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
|
|
{
|
|
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
|
|
|
|
std::size_t BitSize = sizeof(genType) * 8;
|
|
return (In >> Shift) | (In << (BitSize - Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateLeft
|
|
(
|
|
detail::tvec2<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec2<valType>(
|
|
bitRotateLeft(Value[0], Shift),
|
|
bitRotateLeft(Value[1], Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateLeft
|
|
(
|
|
detail::tvec3<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec3<valType>(
|
|
bitRotateLeft(Value[0], Shift),
|
|
bitRotateLeft(Value[1], Shift),
|
|
bitRotateLeft(Value[2], Shift));
|
|
}
|
|
|
|
template <typename valType>
|
|
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateLeft
|
|
(
|
|
detail::tvec4<valType> const & Value,
|
|
std::size_t Shift
|
|
)
|
|
{
|
|
return detail::tvec4<valType>(
|
|
bitRotateLeft(Value[0], Shift),
|
|
bitRotateLeft(Value[1], Shift),
|
|
bitRotateLeft(Value[2], Shift),
|
|
bitRotateLeft(Value[3], Shift));
|
|
}
|
|
|
|
}//namespace bit
|
|
}//namespace gtx
|
|
}//namespace glm
|