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_matrix.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_matrix.hpp
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+/// 
+/// @defgroup core_func_matrix Matrix functions
+/// @ingroup core
+/// 
+/// For each of the following built-in matrix functions, there is both a 
+/// single-precision floating point version, where all arguments and return values 
+/// are single precision, and a double-precision floating version, where all 
+/// arguments and return values are double precision. Only the single-precision 
+/// floating point version is shown.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_CORE_func_matrix
+#define GLM_CORE_func_matrix GLM_VERSION
+
+namespace glm
+{
+	/// @addtogroup core_func_matrix
+	/// @{
+
+	/// Multiply matrix x by matrix y component-wise, i.e., 
+	/// result[i][j] is the scalar product of x[i][j] and y[i][j].
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template <typename matType> 
+	matType matrixCompMult(
+		matType const & x, 
+		matType const & y);
+
+	/// Treats the first parameter c as a column vector 
+	/// and the second parameter r as a row vector
+	/// and does a linear algebraic matrix multiply c * r.
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	/// 
+	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
+	template <typename vecType, typename matType> 
+	matType outerProduct(
+		vecType const & c, 
+		vecType const & r);
+
+	/// Returns the transposed matrix of x
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
+	template <typename matType> 
+	typename matType::transpose_type transpose(
+		matType const & x);
+	
+	/// Return the determinant of a mat2 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
+	template <typename valType> 
+	typename detail::tmat2x2<valType>::value_type determinant(
+		detail::tmat2x2<valType> const & m);
+
+	/// Return the determinant of a mat3 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
+	template <typename valType> 
+	typename detail::tmat3x3<valType>::value_type determinant(
+		detail::tmat3x3<valType> const & m);
+
+	/// Return the determinant of a mat4 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>		
+	template <typename valType> 
+	typename detail::tmat4x4<valType>::value_type determinant(
+		detail::tmat4x4<valType> const & m);
+
+	/// Return the inverse of a mat2 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
+	template <typename valType> 
+	detail::tmat2x2<valType> inverse(
+		detail::tmat2x2<valType> const & m);
+
+	/// Return the inverse of a mat3 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> 
+	template <typename valType> 
+	detail::tmat3x3<valType> inverse(
+		detail::tmat3x3<valType> const & m);
+
+	/// Return the inverse of a mat4 matrix. 
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template <typename valType> 
+	detail::tmat4x4<valType> inverse(
+		detail::tmat4x4<valType> const & m);
+
+	/// @}
+}//namespace glm
+
+#include "func_matrix.inl"
+
+#endif//GLM_CORE_func_matrix

include/gal/opengl/glm/core/hint.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/hint.hpp
+/// @date 2008-08-14 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type
+#define glm_core_type
+
+namespace glm
+{
+	// Use dont_care, nicest and fastest to optimize implementations.
+	class dont_care {};
+	class nicest {};
+	class fastest {};
+}//namespace glm
+
+#endif//glm_core_type