Added functionality for transformation of VBO vertices, extended functions...

Added functionality for transformation of VBO vertices, extended functions like translate, rotate, scale using glm library. Removed D() macro, as it was not used, but in conflict with glm library. Added VBO_ITEMs for circles, semicircles. Now almost everything is drawn using VBO (besides polygons and grid).

common/gal/opengl/vbo_item.cpp

@@ -37,7 +37,8 @@ VBO_ITEM::VBO_ITEM() :
         m_indices( NULL ),
         m_offset( 0 ),
         m_size( 0 ),
-        m_isDirty( true )
+        m_isDirty( true ),
+        m_transform( NULL )
 {
 }
 
@@ -69,6 +70,17 @@ void VBO_ITEM::PushVertex( const GLfloat* aVertex )
     // Add the new vertex
     memcpy( &newVertices[m_size * VertStride], aVertex, VertSize );
 
+    if( m_transform != NULL )
+    {
+        // Apply transformations
+        //                    X,          Y,          Z coordinates
+        glm::vec4 origVertex( aVertex[0], aVertex[1], aVertex[2], 1.0f );
+        glm::vec4 transVertex = *m_transform * origVertex;
+
+        // Replace only coordinates, leave color as it is
+        memcpy( &newVertices[m_size * VertStride], &transVertex[0], 3 * sizeof(GLfloat) );
+    }
+
     // Handle a new index
     if( m_indices )
     {
@@ -104,6 +116,25 @@ void VBO_ITEM::PushVertices( const GLfloat* aVertices, GLuint aSize )
     // Add new vertices
     memcpy( &newVertices[m_size * VertStride], aVertices, aSize * VertSize );
 
+    if( m_transform != NULL )
+    {
+        const GLfloat* vertexPtr = aVertices;
+
+        for( unsigned int i = 0; i < aSize; ++i )
+        {
+            // Apply transformations
+            //                    X,            Y,            Z coordinates
+            glm::vec4 origVertex( vertexPtr[0], vertexPtr[1], vertexPtr[2], 1.0f );
+            glm::vec4 transVertex = *m_transform * origVertex;
+
+            // Replace only coordinates, leave color as it is
+            memcpy( &newVertices[(m_size + i) * VertStride], &transVertex[0], 3 * sizeof(GLfloat) );
+
+            // Move on to the next vertex
+            vertexPtr += VertStride;
+        }
+    }
+
     // Handle new indices
     if( m_indices )
     {
@@ -163,6 +194,38 @@ int VBO_ITEM::GetOffset() const
 }
 
 
+void VBO_ITEM::SetTransformMatrix( const glm::mat4* aMatrix )
+{
+    m_transform = aMatrix;
+}
+
+
+void VBO_ITEM::ChangeColor( const COLOR4D& aColor )
+{
+    // Point to color of vertices
+    GLfloat* vertexPtr = m_vertices + ColorOffset;
+    const GLfloat newColor[] = { aColor.r, aColor.g, aColor.b, aColor.a };
+
+    for( int i = 0; i < m_size; ++i )
+    {
+        memcpy( vertexPtr, newColor, ColorSize );
+
+        // Move on to the next vertex
+        vertexPtr += VertStride;
+    }
+}
+
+
+// TODO it is not used yet
+void VBO_ITEM::UseColor( const COLOR4D& aColor )
+{
+    m_color[0] = aColor.r;
+    m_color[1] = aColor.g;
+    m_color[2] = aColor.b;
+    m_color[3] = aColor.a;
+}
+
+
 /*
 // TODO
 void SetVbo( int aVboId )

include/gal/opengl/glm/core/_fixes.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/_fixes.hpp
+/// @date 2011-02-21 / 2011-11-22
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+

include/gal/opengl/glm/core/_vectorize.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/_vectorize.hpp
+/// @date 2011-10-14 / 2011-10-14
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#define VECTORIZE2_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec2<T> func( \
+		detail::tvec2<T> const & v) \
+	{ \
+		return detail::tvec2<T>( \
+			func(v.x), \
+			func(v.y)); \
+	}
+
+#define VECTORIZE3_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec3<T> func( \
+		detail::tvec3<T> const & v) \
+	{ \
+		return detail::tvec3<T>( \
+			func(v.x), \
+			func(v.y), \
+			func(v.z)); \
+	}
+
+#define VECTORIZE4_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec4<T> func( \
+		detail::tvec4<T> const & v) \
+	{ \
+		return detail::tvec4<T>( \
+			func(v.x), \
+			func(v.y), \
+			func(v.z), \
+			func(v.w)); \
+	}
+
+#define VECTORIZE_VEC(func) \
+	VECTORIZE2_VEC(func) \
+	VECTORIZE3_VEC(func) \
+	VECTORIZE4_VEC(func)
+
+#define VECTORIZE2_VEC_SCA(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec2<T> func \
+	( \
+		detail::tvec2<T> const & x,  \
+		typename detail::tvec2<T>::value_type const & y \
+	) \
+	{ \
+		return detail::tvec2<T>( \
+			func(x.x, y), \
+			func(x.y, y)); \
+	}
+
+#define VECTORIZE3_VEC_SCA(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec3<T> func \
+	( \
+		detail::tvec3<T> const & x,  \
+		typename detail::tvec3<T>::value_type const & y \
+	) \
+	{ \
+		return detail::tvec3<T>( \
+			func(x.x, y), \
+			func(x.y, y), \
+			func(x.z, y)); \
+	}
+
+#define VECTORIZE4_VEC_SCA(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec4<T> func \
+	( \
+		detail::tvec4<T> const & x,  \
+		typename detail::tvec4<T>::value_type const & y \
+	) \
+	{ \
+		return detail::tvec4<T>( \
+			func(x.x, y), \
+			func(x.y, y), \
+			func(x.z, y), \
+			func(x.w, y)); \
+	}
+
+#define VECTORIZE_VEC_SCA(func) \
+	VECTORIZE2_VEC_SCA(func) \
+	VECTORIZE3_VEC_SCA(func) \
+	VECTORIZE4_VEC_SCA(func)
+
+#define VECTORIZE2_VEC_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec2<T> func \
+	( \
+		detail::tvec2<T> const & x,  \
+		detail::tvec2<T> const & y \
+	) \
+	{ \
+		return detail::tvec2<T>( \
+			func(x.x, y.x), \
+			func(x.y, y.y)); \
+	}
+
+#define VECTORIZE3_VEC_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec3<T> func \
+	( \
+		detail::tvec3<T> const & x,  \
+		detail::tvec3<T> const & y \
+	) \
+	{ \
+		return detail::tvec3<T>( \
+			func(x.x, y.x), \
+			func(x.y, y.y), \
+			func(x.z, y.z)); \
+	}
+
+#define VECTORIZE4_VEC_VEC(func) \
+	template <typename T> \
+	GLM_FUNC_QUALIFIER detail::tvec4<T> func \
+	( \
+		detail::tvec4<T> const & x,  \
+		detail::tvec4<T> const & y \
+	) \
+	{ \
+		return detail::tvec4<T>( \
+			func(x.x, y.x), \
+			func(x.y, y.y), \
+			func(x.z, y.z), \
+			func(x.w, y.w)); \
+	}
+
+#define VECTORIZE_VEC_VEC(func) \
+	VECTORIZE2_VEC_VEC(func) \
+	VECTORIZE3_VEC_VEC(func) \
+	VECTORIZE4_VEC_VEC(func)

include/gal/opengl/glm/core/dummy.cpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/dummy.cpp
+/// @date 2011-01-19 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// GLM is a header only library. There is nothing to compile. 
+/// dummy.cpp exist only a wordaround for CMake file.
+///////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include "../glm.hpp"
+
+//#error "GLM is a header only library"
+
+int main()
+{
+
+}

include/gal/opengl/glm/core/func_exponential.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_exponential.hpp
+/// @date 2008-08-08 / 2011-06-14
+/// @author Christophe Riccio
+/// 
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+///
+/// @defgroup core_func_exponential Exponential functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_exponential
+#define glm_core_func_exponential GLM_VERSION
+
+namespace glm
+{
+	/// @addtogroup core_func_exponential
+	/// @{
+
+	/// Returns x raised to the y power. 
+	///
+	/// @param x pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param y 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType pow(genType const & x, genType const & y);
+
+	/// Returns the natural exponentiation of x, i.e., e^x.
+	///
+	/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType exp(genType const & x);
+
+	/// Returns the natural logarithm of x, i.e., 
+	/// returns the value y which satisfies the equation x = e^y. 
+	/// Results are undefined if x <= 0.
+	///
+	/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType log(genType const & x);
+
+	/// Returns 2 raised to the x power.
+	/// 
+	/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType exp2(genType const & x);
+
+	/// Returns the base 2 log of x, i.e., returns the value y, 
+	/// which satisfies the equation x = 2 ^ y.
+	/// 
+	/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType log2(genType const & x);
+
+	/// Returns the positive square root of x.
+	/// 
+	/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType sqrt(genType const & x);
+    
+	/// Returns the reciprocal of the positive square root of x.
+	/// 
+	/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename genType> 
+	genType inversesqrt(genType const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_exponential.inl"
+
+#endif//glm_core_func_exponential

include/gal/opengl/glm/core/func_exponential.inl

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_exponential.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	// pow
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'pow' only accept floating-point input");
+
+		return genType(::std::pow(x, y));
+	}
+
+	VECTORIZE_VEC_VEC(pow)
+
+	// exp
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp' only accept floating-point input");
+
+		return genType(::std::exp(x));
+	}
+
+	VECTORIZE_VEC(exp)
+
+	// log
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log' only accept floating-point input");
+
+		return genType(::std::log(x));
+	}
+
+	VECTORIZE_VEC(log)
+
+	//exp2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp2
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp2' only accept floating-point input");
+
+		return genType(::std::exp(genType(0.69314718055994530941723212145818) * x));
+	}
+
+	VECTORIZE_VEC(exp2)
+
+namespace _detail
+{
+	template <int _PATH = detail::float_or_int_value::GLM_ERROR>
+	struct _compute_log2
+	{
+		template <typename T>
+		T operator() (T const & Value) const;
+/*
+		{
+			GLM_STATIC_ASSERT(0, "'log2' parameter has an invalid template parameter type. GLM core features only supports floating-point types, include <glm/gtx/integer.hpp> for integer types support. Others types are not supported.");
+			return Value;
+		}
+*/
+	};
+
+	template <>
+	struct _compute_log2<detail::float_or_int_value::GLM_FLOAT>
+	{
+		template <typename T>
+		T operator() (T const & Value) const
+		{
+			return T(::std::log(Value)) / T(0.69314718055994530941723212145818);
+		}
+	};
+
+}//namespace _detail
+
+	// log2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log2
+	(
+		genType const & x
+	)
+	{
+		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
+		return _detail::_compute_log2<detail::float_or_int_trait<genType>::ID>()(x);
+	}
+
+	VECTORIZE_VEC(log2)
+
+	// sqrt
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType sqrt
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sqrt' only accept floating-point input");
+
+		return genType(::std::sqrt(x));
+	}
+
+	VECTORIZE_VEC(sqrt)
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
+
+		return genType(1) / ::std::sqrt(x);
+	}
+
+	VECTORIZE_VEC(inversesqrt)
+
+}//namespace glm

include/gal/opengl/glm/core/func_geometric.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_geometric.hpp
+/// @date 2008-08-03 / 2011-06-14
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+/// 
+/// @defgroup core_func_geometric Geometric functions
+/// @ingroup core
+/// 
+/// These operate on vectors as vectors, not component-wise.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_geometric
+#define glm_core_func_geometric GLM_VERSION
+
+namespace glm
+{
+	/// @addtogroup core_func_geometric
+	/// @{
+
+	/// Returns the length of x, i.e., sqrt(x * x).
+	/// 
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+		typename genType::value_type length(
+		genType const & x); 
+
+	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	typename genType::value_type distance(
+		genType const & p0, 
+		genType const & p1);
+
+	/// Returns the dot product of x and y, i.e., result = x * y.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	typename genType::value_type dot(
+		genType const & x, 
+		genType const & y);
+
+	/// Returns the cross product of x and y.
+	///
+	/// @tparam valType Floating-point scalar types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename valType> 
+	detail::tvec3<valType> cross(
+		detail::tvec3<valType> const & x, 
+		detail::tvec3<valType> const & y);
+
+	/// Returns a vector in the same direction as x but with length of 1.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	genType normalize(
+		genType const & x);
+
+	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	genType faceforward(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref);
+
+	/// For the incident vector I and surface orientation N, 
+	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	genType reflect(
+		genType const & I, 
+		genType const & N);
+
+	/// For the incident vector I and surface normal N, 
+	/// and the ratio of indices of refraction eta, 
+	/// return the refraction vector.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType> 
+	genType refract(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta);
+
+	/// @}
+}//namespace glm
+
+#include "func_geometric.inl"
+
+#endif//glm_core_func_geometric

include/gal/opengl/glm/core/func_geometric.inl

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_geometric.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	// length
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType length
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'length' only accept floating-point inputs");
+
+		genType sqr = x * x;
+		return sqrt(sqr);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type length
+	(
+		detail::tvec2<T> const & v
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+		typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
+		return sqrt(sqr);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type length
+	(
+		detail::tvec3<T> const & v
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+		typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
+		return sqrt(sqr);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type length
+	(
+		detail::tvec4<T> const & v
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+		typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
+		return sqrt(sqr);
+	}
+
+	// distance
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType distance
+	(
+		genType const & p0, 
+		genType const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+ 
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type distance
+	(
+		detail::tvec2<T> const & p0,
+		detail::tvec2<T> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type distance
+	(
+		detail::tvec3<T> const & p0,
+		detail::tvec3<T> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type distance
+	(
+		detail::tvec4<T> const & p0,
+		detail::tvec4<T> const & p1
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	// dot
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType dot
+	(
+		genType const & x, 
+		genType const & y
+        
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");
+
+		return x * y;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type dot
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+		return x.x * y.x + x.y * y.y;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T dot
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+		return x.x * y.x + x.y * y.y + x.z * y.z;
+	}
+/* // SSE3
+	GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
+	{
+		float Result;
+		__asm
+		{
+			mov		esi, x
+			mov		edi, y
+			movaps	xmm0, [esi]
+			mulps	xmm0, [edi]
+			haddps(	_xmm0, _xmm0 )
+			haddps(	_xmm0, _xmm0 )
+			movss	Result, xmm0
+		}
+		return Result;
+	}
+*/
+	template <typename T>
+	GLM_FUNC_QUALIFIER T dot
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+		return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
+	}
+
+	// cross
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> cross
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'cross' only accept floating-point inputs");
+
+		return detail::tvec3<T>(
+			x.y * y.z - y.y * x.z,
+			x.z * y.x - y.z * x.x,
+			x.x * y.y - y.x * x.y);
+	}
+
+	// normalize
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType normalize
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'normalize' only accept floating-point inputs");
+
+		return x < genType(0) ? genType(-1) : genType(1);
+	}
+
+	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> normalize
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+		
+		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
+		return x * inversesqrt(sqr);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> normalize
+	(
+		detail::tvec3<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+
+		typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+		return x * inversesqrt(sqr);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> normalize
+	(
+		detail::tvec4<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+		
+		typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+		return x * inversesqrt(sqr);
+	}
+
+	// faceforward
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward
+	(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref
+	)
+	{
+		return dot(Nref, I) < 0 ? N : -N;
+	}
+
+	// reflect
+	template <typename genType>
+	genType reflect
+	(
+		genType const & I, 
+		genType const & N
+	)
+	{
+		return I - N * dot(N, I) * genType(2);
+	}
+
+	// refract
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType refract
+	(
+		genType const & I, 
+		genType const & N, 
+		genType const & eta
+	)
+	{
+		//It could be a vector
+		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		genType dotValue = dot(N, I);
+		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
+		if(k < genType(0))
+			return genType(0);
+		else
+			return eta * I - (eta * dotValue + sqrt(k)) * N;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType refract
+	(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta
+	)
+	{
+		//It could be a vector
+		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		typename genType::value_type dotValue = dot(N, I);
+		typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
+		if(k < typename genType::value_type(0))
+			return genType(0);
+		else
+			return eta * I - (eta * dotValue + sqrt(k)) * N;
+	}
+
+}//namespace glm

include/gal/opengl/glm/core/func_integer.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_integer.hpp
+/// @date 2010-03-17 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+/// 
+/// @defgroup core_func_integer Integer functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component. 
+/// The notation [a, b] means the set of bits from bit-number a through bit-number 
+/// b, inclusive. The lowest-order bit is bit 0.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_integer
+#define glm_core_func_integer GLM_VERSION
+
+namespace glm
+{
+	/// @addtogroup core_func_integer
+	/// @{
+
+	/// Adds 32-bit unsigned integer x and y, returning the sum
+	/// modulo pow(2, 32). The value carry is set to 0 if the sum was
+	/// less than pow(2, 32), or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	genUType uaddCarry(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & carry);
+
+	/// Subtracts the 32-bit unsigned integer y from x, returning
+	/// the difference if non-negative, or pow(2, 32) plus the difference
+	/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	genUType usubBorrow(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & borrow);
+		
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genUType>
+	void umulExtended(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & msb, 
+		genUType & lsb);
+		
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	/// 
+	/// @tparam genIType Signed integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIType>
+	void imulExtended(
+		genIType const & x, 
+		genIType const & y, 
+		genIType & msb, 
+		genIType & lsb);
+
+	/// Extracts bits [offset, offset + bits - 1] from value,
+	/// returning them in the least significant bits of the result.
+	/// For unsigned data types, the most significant bits of the
+	/// result will be set to zero. For signed data types, the
+	/// most significant bits will be set to the value of bit offset + base – 1.
+	///
+	/// If bits is zero, the result will be zero. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used
+	/// to store the operand.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	genIUType bitfieldExtract(
+		genIUType const & Value, 
+		int const & Offset, 
+		int const & Bits);
+
+	/// Returns the insertion the bits least-significant bits of insert into base.
+	///
+	/// The result will have bits [offset, offset + bits - 1] taken
+	/// from bits [0, bits – 1] of insert, and all other bits taken
+	/// directly from the corresponding bits of base. If bits is
+	/// zero, the result will simply be base. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used to
+	/// store the operand.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	genIUType bitfieldInsert(
+		genIUType const & Base, 
+		genIUType const & Insert, 
+		int const & Offset, 
+		int const & Bits);
+
+	/// Returns the reversal of the bits of value. 
+	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
+	/// where bits is the total number of bits used to represent value.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	genIUType bitfieldReverse(genIUType const & Value);
+		
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
+
+	/// @}
+}//namespace glm
+
+#include "func_integer.inl"
+
+#endif//glm_core_func_integer
+

include/gal/opengl/glm/core/func_noise.hpp

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/func_noise.hpp
+/// @date 2008-08-01 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+/// 
+/// @defgroup core_func_noise Noise functions
+/// @ingroup core
+/// 
+/// Noise functions are stochastic functions that can be used to increase visual 
+/// complexity. Values returned by the following noise functions give the 
+/// appearance of randomness, but are not truly random.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_noise
+#define glm_core_func_noise GLM_VERSION
+
+namespace glm
+{
+	/// @addtogroup core_func_noise
+	/// @{
+
+	/// Returns a 1D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	typename genType::value_type noise1(genType const & x);
+
+	/// Returns a 2D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	detail::tvec2<typename genType::value_type> noise2(genType const & x);
+
+	/// Returns a 3D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	detail::tvec3<typename genType::value_type> noise3(genType const & x);
+
+	/// Returns a 4D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	detail::tvec4<typename genType::value_type> noise4(genType const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_noise.inl"
+
+#endif//glm_core_func_noise

include/gal/opengl/glm/core/intrinsic_exponential.inl

+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// 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 core
+/// @file glm/core/intrinsic_exponential.inl
+/// @date 2011-06-15 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////