summaryrefslogtreecommitdiff
path: root/include/gal/opengl/glm/gtx/integer.inl
diff options
context:
space:
mode:
authorsaurabhb172020-02-26 16:04:40 +0530
committersaurabhb172020-02-26 16:04:40 +0530
commit039ac92480a09266146fc5b0c9ec67a32a2565ad (patch)
tree7b6cef031a580680690a0f32410db940f7e7d7d5 /include/gal/opengl/glm/gtx/integer.inl
parentaa35045840b78d3f48212db45da59a2e5c69b223 (diff)
downloadKiCad-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.inl203
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