-removed glm library, its in the debian repos

-made opengl and sdl folders in includes, moved various *hpps to them

1 files changed, 0 insertions, 542 deletions

diff --git a/inc/glm/gtc/bitfield.inl b/inc/glm/gtc/bitfield.inl
deleted file mode 100644
index ddd8fc0..0000000
--- a/inc/glm/gtc/bitfield.inl
+++ /dev/null
@@ -1,542 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////

-/// OpenGL Mathematics (glm.g-truc.net)

-///

-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)

-/// Permission is hereby granted, free of charge, to any person obtaining a copy

-/// of this software and associated documentation files (the "Software"), to deal

-/// in the Software without restriction, including without limitation the rights

-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-/// copies of the Software, and to permit persons to whom the Software is

-/// furnished to do so, subject to the following conditions:

-/// 

-/// The above copyright notice and this permission notice shall be included in

-/// all copies or substantial portions of the Software.

-/// 

-/// Restrictions:

-///		By making use of the Software for military purposes, you choose to make

-///		a Bunny unhappy.

-/// 

-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

-/// THE SOFTWARE.

-///

-/// @ref gtc_bitfield

-/// @file glm/gtc/bitfield.inl

-/// @date 2011-10-14 / 2012-01-25

-/// @author Christophe Riccio

-///////////////////////////////////////////////////////////////////////////////////

-

-namespace glm{

-namespace detail

-{

-	template <typename PARAM, typename RET>

-	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);

-

-	template <typename PARAM, typename RET>

-	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);

-

-	template <typename PARAM, typename RET>

-	GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)

-	{

-		glm::uint16 REG1(x);

-		glm::uint16 REG2(y);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint16(0x0F0F);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint16(0x0F0F);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint16(0x3333);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint16(0x3333);

-

-		REG1 = ((REG1 <<  1) | REG1) & glm::uint16(0x5555);

-		REG2 = ((REG2 <<  1) | REG2) & glm::uint16(0x5555);

-

-		return REG1 | (REG2 << 1);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)

-	{

-		glm::uint32 REG1(x);

-		glm::uint32 REG2(y);

-

-		REG1 = ((REG1 <<  8) | REG1) & glm::uint32(0x00FF00FF);

-		REG2 = ((REG2 <<  8) | REG2) & glm::uint32(0x00FF00FF);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint32(0x0F0F0F0F);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint32(0x0F0F0F0F);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint32(0x33333333);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint32(0x33333333);

-

-		REG1 = ((REG1 <<  1) | REG1) & glm::uint32(0x55555555);

-		REG2 = ((REG2 <<  1) | REG2) & glm::uint32(0x55555555);

-

-		return REG1 | (REG2 << 1);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)

-	{

-		glm::uint64 REG1(x);

-		glm::uint64 REG2(y);

-

-		REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);

-		REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);

-

-		REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);

-		REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);

-

-		REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);

-		REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);

-

-		return REG1 | (REG2 << 1);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)

-	{

-		glm::uint32 REG1(x);

-		glm::uint32 REG2(y);

-		glm::uint32 REG3(z);

-

-		REG1 = ((REG1 << 16) | REG1) & glm::uint32(0x00FF0000FF0000FF);

-		REG2 = ((REG2 << 16) | REG2) & glm::uint32(0x00FF0000FF0000FF);

-		REG3 = ((REG3 << 16) | REG3) & glm::uint32(0x00FF0000FF0000FF);

-

-		REG1 = ((REG1 <<  8) | REG1) & glm::uint32(0xF00F00F00F00F00F);

-		REG2 = ((REG2 <<  8) | REG2) & glm::uint32(0xF00F00F00F00F00F);

-		REG3 = ((REG3 <<  8) | REG3) & glm::uint32(0xF00F00F00F00F00F);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint32(0x30C30C30C30C30C3);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint32(0x30C30C30C30C30C3);

-		REG3 = ((REG3 <<  4) | REG3) & glm::uint32(0x30C30C30C30C30C3);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint32(0x9249249249249249);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint32(0x9249249249249249);

-		REG3 = ((REG3 <<  2) | REG3) & glm::uint32(0x9249249249249249);

-

-		return REG1 | (REG2 << 1) | (REG3 << 2);

-	}

-		

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)

-	{

-		glm::uint64 REG1(x);

-		glm::uint64 REG2(y);

-		glm::uint64 REG3(z);

-

-		REG1 = ((REG1 << 32) | REG1) & glm::uint64(0xFFFF00000000FFFF);

-		REG2 = ((REG2 << 32) | REG2) & glm::uint64(0xFFFF00000000FFFF);

-		REG3 = ((REG3 << 32) | REG3) & glm::uint64(0xFFFF00000000FFFF);

-

-		REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x00FF0000FF0000FF);

-		REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x00FF0000FF0000FF);

-		REG3 = ((REG3 << 16) | REG3) & glm::uint64(0x00FF0000FF0000FF);

-

-		REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0xF00F00F00F00F00F);

-		REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0xF00F00F00F00F00F);

-		REG3 = ((REG3 <<  8) | REG3) & glm::uint64(0xF00F00F00F00F00F);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x30C30C30C30C30C3);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x30C30C30C30C30C3);

-		REG3 = ((REG3 <<  4) | REG3) & glm::uint64(0x30C30C30C30C30C3);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x9249249249249249);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x9249249249249249);

-		REG3 = ((REG3 <<  2) | REG3) & glm::uint64(0x9249249249249249);

-

-		return REG1 | (REG2 << 1) | (REG3 << 2);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)

-	{

-		glm::uint64 REG1(x);

-		glm::uint64 REG2(y);

-		glm::uint64 REG3(z);

-

-		REG1 = ((REG1 << 32) | REG1) & glm::uint64(0xFFFF00000000FFFF);

-		REG2 = ((REG2 << 32) | REG2) & glm::uint64(0xFFFF00000000FFFF);

-		REG3 = ((REG3 << 32) | REG3) & glm::uint64(0xFFFF00000000FFFF);

-

-		REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x00FF0000FF0000FF);

-		REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x00FF0000FF0000FF);

-		REG3 = ((REG3 << 16) | REG3) & glm::uint64(0x00FF0000FF0000FF);

-

-		REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0xF00F00F00F00F00F);

-		REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0xF00F00F00F00F00F);

-		REG3 = ((REG3 <<  8) | REG3) & glm::uint64(0xF00F00F00F00F00F);

-

-		REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x30C30C30C30C30C3);

-		REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x30C30C30C30C30C3);

-		REG3 = ((REG3 <<  4) | REG3) & glm::uint64(0x30C30C30C30C30C3);

-

-		REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x9249249249249249);

-		REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x9249249249249249);

-		REG3 = ((REG3 <<  2) | REG3) & glm::uint64(0x9249249249249249);

-

-		return REG1 | (REG2 << 1) | (REG3 << 2);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)

-	{

-		glm::uint32 REG1(x);

-		glm::uint32 REG2(y);

-		glm::uint32 REG3(z);

-		glm::uint32 REG4(w);

-

-		REG1 = ((REG1 << 12) | REG1) & glm::uint32(0x000F000F000F000F);

-		REG2 = ((REG2 << 12) | REG2) & glm::uint32(0x000F000F000F000F);

-		REG3 = ((REG3 << 12) | REG3) & glm::uint32(0x000F000F000F000F);

-		REG4 = ((REG4 << 12) | REG4) & glm::uint32(0x000F000F000F000F);

-

-		REG1 = ((REG1 <<  6) | REG1) & glm::uint32(0x0303030303030303);

-		REG2 = ((REG2 <<  6) | REG2) & glm::uint32(0x0303030303030303);

-		REG3 = ((REG3 <<  6) | REG3) & glm::uint32(0x0303030303030303);

-		REG4 = ((REG4 <<  6) | REG4) & glm::uint32(0x0303030303030303);

-

-		REG1 = ((REG1 <<  3) | REG1) & glm::uint32(0x1111111111111111);

-		REG2 = ((REG2 <<  3) | REG2) & glm::uint32(0x1111111111111111);

-		REG3 = ((REG3 <<  3) | REG3) & glm::uint32(0x1111111111111111);

-		REG4 = ((REG4 <<  3) | REG4) & glm::uint32(0x1111111111111111);

-

-		return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);

-	}

-

-	template <>

-	GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)

-	{

-		glm::uint64 REG1(x);

-		glm::uint64 REG2(y);

-		glm::uint64 REG3(z);

-		glm::uint64 REG4(w);

-

-		REG1 = ((REG1 << 24) | REG1) & glm::uint64(0x000000FF000000FF);

-		REG2 = ((REG2 << 24) | REG2) & glm::uint64(0x000000FF000000FF);

-		REG3 = ((REG3 << 24) | REG3) & glm::uint64(0x000000FF000000FF);

-		REG4 = ((REG4 << 24) | REG4) & glm::uint64(0x000000FF000000FF);

-

-		REG1 = ((REG1 << 12) | REG1) & glm::uint64(0x000F000F000F000F);

-		REG2 = ((REG2 << 12) | REG2) & glm::uint64(0x000F000F000F000F);

-		REG3 = ((REG3 << 12) | REG3) & glm::uint64(0x000F000F000F000F);

-		REG4 = ((REG4 << 12) | REG4) & glm::uint64(0x000F000F000F000F);

-

-		REG1 = ((REG1 <<  6) | REG1) & glm::uint64(0x0303030303030303);

-		REG2 = ((REG2 <<  6) | REG2) & glm::uint64(0x0303030303030303);

-		REG3 = ((REG3 <<  6) | REG3) & glm::uint64(0x0303030303030303);

-		REG4 = ((REG4 <<  6) | REG4) & glm::uint64(0x0303030303030303);

-

-		REG1 = ((REG1 <<  3) | REG1) & glm::uint64(0x1111111111111111);

-		REG2 = ((REG2 <<  3) | REG2) & glm::uint64(0x1111111111111111);

-		REG3 = ((REG3 <<  3) | REG3) & glm::uint64(0x1111111111111111);

-		REG4 = ((REG4 <<  3) | REG4) & glm::uint64(0x1111111111111111);

-

-		return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);

-	}

-}//namespace detail

-

-	template <typename genIUType>

-	GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'mask' accepts only integer values");

-

-		return Bits >= sizeof(genIUType) * 8 ? ~static_cast<genIUType>(0) : (static_cast<genIUType>(1) << Bits) - static_cast<genIUType>(1);

-	}

-

-	template <typename T, precision P, template <typename, precision> class vecIUType>

-	GLM_FUNC_QUALIFIER vecIUType<T, P> mask(vecIUType<T, P> const & v)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");

-

-		return detail::functor1<T, T, P, vecIUType>::call(mask, v);

-	}

-

-	template <typename genIType>

-	GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateRight' accepts only integer values");

-

-		int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);

-		return (In << static_cast<genIType>(Shift)) | (In >> static_cast<genIType>(BitSize - Shift));

-	}

-

-	template <typename T, precision P, template <typename, precision> class vecType>

-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateRight(vecType<T, P> const & In, int Shift)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");

-

-		int const BitSize = static_cast<int>(sizeof(T) * 8);

-		return (In << static_cast<T>(Shift)) | (In >> static_cast<T>(BitSize - Shift));

-	}

-

-	template <typename genIType>

-	GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateLeft' accepts only integer values");

-

-		int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);

-		return (In >> static_cast<genIType>(Shift)) | (In << static_cast<genIType>(BitSize - Shift));

-	}

-

-	template <typename T, precision P, template <typename, precision> class vecType>

-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldRotateLeft(vecType<T, P> const & In, int Shift)

-	{

-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");

-

-		int const BitSize = static_cast<int>(sizeof(T) * 8);

-		return (In >> static_cast<T>(Shift)) | (In << static_cast<T>(BitSize - Shift));

-	}

-

-	template <typename genIUType>

-	GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)

-	{

-		return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);

-	}

-

-	template <typename T, precision P, template <typename, precision> class vecType>

-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillOne(vecType<T, P> const & Value, int FirstBit, int BitCount)

-	{

-		return Value | static_cast<T>(mask(BitCount) << FirstBit);

-	}

-

-	template <typename genIUType>

-	GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)

-	{

-		return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));

-	}

-

-	template <typename T, precision P, template <typename, precision> class vecType>

-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldFillZero(vecType<T, P> const & Value, int FirstBit, int BitCount)

-	{

-		return Value & static_cast<T>(~(mask(BitCount) << FirstBit));

-	}

-

-	GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)

-	{

-		union sign8

-		{

-			int8 i;

-			uint8 u;

-		} sign_x, sign_y;

-

-		union sign16

-		{

-			int16 i;

-			uint16 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)

-	{

-		return detail::bitfieldInterleave<uint8, uint16>(x, y);

-	}

-

-	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)

-	{

-		union sign16

-		{

-			int16 i;

-			uint16 u;

-		} sign_x, sign_y;

-

-		union sign32

-		{

-			int32 i;

-			uint32 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)

-	{

-		return detail::bitfieldInterleave<uint16, uint32>(x, y);

-	}

-

-	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)

-	{

-		union sign32

-		{

-			int32 i;

-			uint32 u;

-		} sign_x, sign_y;

-

-		union sign64

-		{

-			int64 i;

-			uint64 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)

-	{

-		return detail::bitfieldInterleave<uint32, uint64>(x, y);

-	}

-

-	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)

-	{

-		union sign8

-		{

-			int8 i;

-			uint8 u;

-		} sign_x, sign_y, sign_z;

-

-		union sign32

-		{

-			int32 i;

-			uint32 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		sign_z.i = z;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)

-	{

-		return detail::bitfieldInterleave<uint8, uint32>(x, y, z);

-	}

-

-	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)

-	{

-		union sign16

-		{

-			int16 i;

-			uint16 u;

-		} sign_x, sign_y, sign_z;

-

-		union sign64

-		{

-			int64 i;

-			uint64 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		sign_z.i = z;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)

-	{

-		return detail::bitfieldInterleave<uint32, uint64>(x, y, z);

-	}

-

-	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)

-	{

-		union sign16

-		{

-			int32 i;

-			uint32 u;

-		} sign_x, sign_y, sign_z;

-

-		union sign64

-		{

-			int64 i;

-			uint64 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		sign_z.i = z;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)

-	{

-		return detail::bitfieldInterleave<uint32, uint64>(x, y, z);

-	}

-

-	GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)

-	{

-		union sign8

-		{

-			int8 i;

-			uint8 u;

-		} sign_x, sign_y, sign_z, sign_w;

-

-		union sign32

-		{

-			int32 i;

-			uint32 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		sign_z.i = z;

-		sign_w.i = w;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)

-	{

-		return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);

-	}

-

-	GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)

-	{

-		union sign16

-		{

-			int16 i;

-			uint16 u;

-		} sign_x, sign_y, sign_z, sign_w;

-

-		union sign64

-		{

-			int64 i;

-			uint64 u;

-		} result;

-

-		sign_x.i = x;

-		sign_y.i = y;

-		sign_z.i = z;

-		sign_w.i = w;

-		result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);

-

-		return result.i;

-	}

-

-	GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)

-	{

-		return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);

-	}

-}//namespace glm