anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Added powerOfTwo functions

Browse Source
master
Christophe Riccio ago%!(EXTRA string=11 years)
parent 0de2f5c587
commit 031eb13341
2 changed files with 74 additions and 61 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 36
      glm/gtc/integer.hpp
  2. 99
      glm/gtc/integer.inl

36
glm/gtc/integer.hpp
Unescape View File

@ -67,53 +67,45 @@ namespace glm
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<bool, P> isPowerOfTwo(vecType<T, P> const & value);
/// Find the highest bit set to 1 in a integer variable and return its value.
/// Return the power of two number which value is just higher the input value,
/// round up to a power of two.
///
/// @see gtc_integer
template <typename genIUType>
GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value);
/// Find the highest bit set to 1 in a integer variable and return its value.
/// Return the power of two number which value is just higher the input value,
/// round up to a power of two.
///
/// @see gtc_integer
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> highestBitValue(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & value);
/// Return the power of two number which value is just higher the input value.
/// Return the power of two number which value is just lower the input value,
/// round down to a power of two.
///
/// @see gtc_integer
template <typename genIUType>
GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value);
/// Return the power of two number which value is just higher the input value.
/// Return the power of two number which value is just lower the input value,
/// round down to a power of two.
///
/// @see gtc_integer
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> powerOfTwoAbove(vecType<T, P> const & value);
/// Return the power of two number which value is just lower the input value.
///
/// @see gtc_integer
template <typename genIUType>
GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
/// Return the power of two number which value is just lower the input value.
///
/// @see gtc_integer
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> powerOfTwoBelow(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> floorPowerOfTwo(vecType<T, P> const & value);
/// Return the power of two number which value is the closet to the input value.
///
/// @see gtc_integer
template <typename genIUType>
GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value);
/// Return the power of two number which value is the closet to the input value.
///
/// @see gtc_integer
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> powerOfTwoNearest(vecType<T, P> const & value);
GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value);
/// @}
} //namespace glm

99
glm/gtc/integer.inl
Unescape View File

@ -26,82 +26,103 @@
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
namespace glm{
namespace detail
{
////////////////
// isPowerOfTwo
template <typename T, precision P, template <class, precision> class vecType, bool isSigned = true>
struct compute_ceilPowerOfTwo{};
template <typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
template <typename T, precision P, template <class, precision> class vecType>
struct compute_ceilPowerOfTwo<T, P, vecType, false>
{
genType Result = glm::abs(Value);
return !(Result & (Result - 1));
}
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v)
{
GLM_STATIC_ASSERT(
!std::numeric_limits<genFIType>::is_iec559,
"'ceilPowerOfTwo' only accept integer scalar or vector inputs");
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<bool, P> isPowerOfTwo(vecType<T, P> const & Value)
template <typename T, precision P, template <class, precision> class vecType, bool compute = false>
struct compute_ceil_shift
{
vecType<T, P> Result(abs(Value));
return equal(Result & (Result - 1), vecType<T, P>(0));
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T)
{
return v;
}
};
///////////////////
// highestBitValue
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
template <typename T, precision P, template <class, precision> class vecType, bool compute = true>
struct compute_ceil_shift
{
genIUType tmp = Value;
genIUType result = genIUType(0);
while(tmp)
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Shift)
{
result = (tmp & (~tmp + 1)); // grab lowest bit
tmp &= ~result; // clear lowest bit
return v | (v >> Shift);
}
return result;
};
v = v - static_cast<T>(1);
v = v | (v >> static_cast<T>(1));
v = v | (v >> static_cast<T>(2));
v = v | (v >> static_cast<T>(4));
v = compute_ceil_shift<T, P, vecType, sizeof(T) >= 2>::call(v, 8);
v = compute_ceil_shift<T, P, vecType, sizeof(T) >= 4>::call(v, 16);
v = compute_ceil_shift<T, P, vecType, sizeof(T) >= 8>::call(v, 32);
return v + static_cast<T>(1);
}
};
}//namespace detail
////////////////
// isPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
{
genType const Result = glm::abs(Value);
return !(Result & (Result - 1));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> highestBitValue(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<bool, P> isPowerOfTwo(vecType<T, P> const & Value)
{
return detail::functor1<T, T, P, vecType>::call(highestBitValue, v);
vecType<T, P> const Result(abs(Value));
return equal(Result & (Result - 1), vecType<T, P>(0));
}
///////////////////
// powerOfTwoAbove
//////////////////
// ceilPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value)
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoAbove(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> ceilPowerOfTwo(vecType<T, P> const & v)
{
return detail::functor1<T, T, P, vecType>::call(powerOfTwoAbove, v);
return detail::functor1<T, T, P, vecType>::call(ceilPowerOfTwo, v);
}
///////////////////
// powerOfTwoBelow
// floorPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value)
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoBelow(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> floorPowerOfTwo(vecType<T, P> const & v)
{
return detail::functor1<T, T, P, vecType>::call(powerOfTwoBelow, v);
return detail::functor1<T, T, P, vecType>::call(floorPowerOfTwo, v);
}
/////////////////////
// powerOfTwoNearest
///////////////////
// roundPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value)
GLM_FUNC_QUALIFIER genType roundPowerOfTwo(genType value)
{
if(isPowerOfTwo(value))
return value;
@ -112,8 +133,8 @@ namespace glm
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoNearest(vecType<T, P> const & v)
GLM_FUNC_QUALIFIER vecType<T, P> roundPowerOfTwo(vecType<T, P> const & v)
{
return detail::functor1<T, T, P, vecType>::call(powerOfTwoNearest, v);
return detail::functor1<T, T, P, vecType>::call(roundPowerOfTwo, v);
}
}//namespace glm

Write Preview
Loading…
Cancel
Save