Merge pull request #3 from saurabhb17/master

secondary files

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