summaryrefslogtreecommitdiff
path: root/include/gal/opengl/glm/gtx/bit.inl
diff options
context:
space:
mode:
Diffstat (limited to 'include/gal/opengl/glm/gtx/bit.inl')
-rw-r--r--include/gal/opengl/glm/gtx/bit.inl600
1 files changed, 600 insertions, 0 deletions
diff --git a/include/gal/opengl/glm/gtx/bit.inl b/include/gal/opengl/glm/gtx/bit.inl
new file mode 100644
index 0000000..27647ae
--- /dev/null
+++ b/include/gal/opengl/glm/gtx/bit.inl
@@ -0,0 +1,600 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 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
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+ template <typename genIType>
+ GLM_FUNC_QUALIFIER genIType mask
+ (
+ genIType const & count
+ )
+ {
+ return ((genIType(1) << (count)) - genIType(1));
+ }
+
+ VECTORIZE_VEC(mask)
+
+ // extractField
+ template <typename genIType>
+ GLM_FUNC_QUALIFIER genIType extractField
+ (
+ half const & value,
+ genIType const & first,
+ genIType const & count
+ )
+ {
+ assert(first + count < sizeof(half));
+ return (value._data() << first) >> ((sizeof(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;
+ }
+
+ VECTORIZE_VEC(powerOfTwoAbove)
+
+ // powerOfTwoBelow
+ template <typename genType>
+ GLM_FUNC_QUALIFIER genType powerOfTwoBelow
+ (
+ genType const & value
+ )
+ {
+ return isPowerOfTwo(value) ? value : highestBitValue(value);
+ }
+
+ VECTORIZE_VEC(powerOfTwoBelow)
+
+ // 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;
+ }
+
+ VECTORIZE_VEC(powerOfTwoNearest)
+
+ 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;
+ }
+
+ VECTORIZE_VEC(bitRevert)
+
+ 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));
+ }
+
+ template <typename genIUType>
+ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithOne
+ (
+ genIUType const & Value,
+ int const & FromBit,
+ int const & ToBit
+ )
+ {
+ assert(FromBit <= ToBit);
+ assert(ToBit <= sizeof(genIUType) * std::size_t(8));
+
+ genIUType Result = Value;
+ for(std::size_t i = 0; i <= ToBit; ++i)
+ Result |= (1 << i);
+ return Result;
+ }
+
+ template <typename genIUType>
+ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
+ (
+ genIUType const & Value,
+ int const & FromBit,
+ int const & ToBit
+ )
+ {
+ assert(FromBit <= ToBit);
+ assert(ToBit <= sizeof(genIUType) * std::size_t(8));
+
+ genIUType Result = Value;
+ for(std::size_t i = 0; i <= ToBit; ++i)
+ Result &= ~(1 << i);
+ return Result;
+ }
+}//namespace glm
generated by cgit (git 2.34.1) at 2024-12-19 09:46:13 +0000