diff options
author | saurabhb17 | 2020-02-26 16:04:40 +0530 |
---|---|---|
committer | saurabhb17 | 2020-02-26 16:04:40 +0530 |
commit | 039ac92480a09266146fc5b0c9ec67a32a2565ad (patch) | |
tree | 7b6cef031a580680690a0f32410db940f7e7d7d5 /include/gal/opengl/glm/gtx/integer.inl | |
parent | aa35045840b78d3f48212db45da59a2e5c69b223 (diff) | |
download | KiCad-eSim-039ac92480a09266146fc5b0c9ec67a32a2565ad.tar.gz KiCad-eSim-039ac92480a09266146fc5b0c9ec67a32a2565ad.tar.bz2 KiCad-eSim-039ac92480a09266146fc5b0c9ec67a32a2565ad.zip |
Added secondary files
Diffstat (limited to 'include/gal/opengl/glm/gtx/integer.inl')
-rw-r--r-- | include/gal/opengl/glm/gtx/integer.inl | 203 |
1 files changed, 203 insertions, 0 deletions
diff --git a/include/gal/opengl/glm/gtx/integer.inl b/include/gal/opengl/glm/gtx/integer.inl new file mode 100644 index 0000000..2478616 --- /dev/null +++ b/include/gal/opengl/glm/gtx/integer.inl @@ -0,0 +1,203 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Created : 2005-12-24 +// Updated : 2011-10-13 +// Licence : This source is under MIT License +// File : glm/gtx/integer.inl +/////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace glm +{ + // pow + GLM_FUNC_QUALIFIER int pow(int x, int y) + { + if(y == 0) + return 1; + int result = x; + for(int i = 1; i < y; ++i) + result *= x; + return result; + } + + // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387 + GLM_FUNC_QUALIFIER int sqrt(int x) + { + if(x <= 1) return x; + + int NextTrial = x >> 1; + int CurrentAnswer; + + do + { + CurrentAnswer = NextTrial; + NextTrial = (NextTrial + x / NextTrial) >> 1; + } while(NextTrial < CurrentAnswer); + + return CurrentAnswer; + } + +// Henry Gordon Dietz: http://aggregate.org/MAGIC/ +namespace _detail +{ + GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x) + { + /* 32-bit recursive reduction using SWAR... + but first step is mapping 2-bit values + into sum of 2 1-bit values in sneaky way + */ + x -= ((x >> 1) & 0x55555555); + x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); + x = (((x >> 4) + x) & 0x0f0f0f0f); + x += (x >> 8); + x += (x >> 16); + return(x & 0x0000003f); + } + + template <> + struct _compute_log2<detail::float_or_int_value::GLM_INT> + { + template <typename T> + GLM_FUNC_QUALIFIER T operator() (T const & Value) const + { +#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC)) + return Value <= T(1) ? T(0) : T(32) - nlz(Value - T(1)); +#else + return T(32) - nlz(Value - T(1)); +#endif + } + }; + +}//namespace _detail + + // Henry Gordon Dietz: http://aggregate.org/MAGIC/ +/* + GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x) + { + x |= (x >> 1); + x |= (x >> 2); + x |= (x >> 4); + x |= (x >> 8); + x |= (x >> 16); + + return _detail::ones32(x) >> 1; + } +*/ + // mod + GLM_FUNC_QUALIFIER int mod(int x, int y) + { + return x - y * (x / y); + } + + // factorial (!12 max, integer only) + template <typename genType> + GLM_FUNC_QUALIFIER genType factorial(genType const & x) + { + genType Temp = x; + genType Result; + for(Result = 1; Temp > 1; --Temp) + Result *= Temp; + return Result; + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec2<valType> factorial( + detail::tvec2<valType> const & x) + { + return detail::tvec2<valType>( + factorial(x.x), + factorial(x.y)); + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec3<valType> factorial( + detail::tvec3<valType> const & x) + { + return detail::tvec3<valType>( + factorial(x.x), + factorial(x.y), + factorial(x.z)); + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial( + detail::tvec4<valType> const & x) + { + return detail::tvec4<valType>( + factorial(x.x), + factorial(x.y), + factorial(x.z), + factorial(x.w)); + } + + GLM_FUNC_QUALIFIER uint pow(uint x, uint y) + { + uint result = x; + for(uint i = 1; i < y; ++i) + result *= x; + return result; + } + + GLM_FUNC_QUALIFIER uint sqrt(uint x) + { + if(x <= 1) return x; + + uint NextTrial = x >> 1; + uint CurrentAnswer; + + do + { + CurrentAnswer = NextTrial; + NextTrial = (NextTrial + x / NextTrial) >> 1; + } while(NextTrial < CurrentAnswer); + + return CurrentAnswer; + } + + GLM_FUNC_QUALIFIER uint mod(uint x, uint y) + { + return x - y * (x / y); + } + +#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC)) + + GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) + { + return 31u - findMSB(x); + } + +#else + + // Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt + GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) + { + int y, m, n; + + y = -int(x >> 16); // If left half of x is 0, + m = (y >> 16) & 16; // set n = 16. If left half + n = 16 - m; // is nonzero, set n = 0 and + x = x >> m; // shift x right 16. + // Now x is of the form 0000xxxx. + y = x - 0x100; // If positions 8-15 are 0, + m = (y >> 16) & 8; // add 8 to n and shift x left 8. + n = n + m; + x = x << m; + + y = x - 0x1000; // If positions 12-15 are 0, + m = (y >> 16) & 4; // add 4 to n and shift x left 4. + n = n + m; + x = x << m; + + y = x - 0x4000; // If positions 14-15 are 0, + m = (y >> 16) & 2; // add 2 to n and shift x left 2. + n = n + m; + x = x << m; + + y = x >> 14; // Set y = 0, 1, 2, or 3. + m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp. + return unsigned(n + 2 - m); + } + +#endif//(GLM_COMPILER) + +}//namespace glm |