Merge branch 'devel'

.gitmodules

+[submodule "3rdparty/pybind11"]
+	path = 3rdparty/pybind11
+	url = https://github.com/pybind/pybind11.git
+[submodule "3rdparty/glm"]
+	path = 3rdparty/glm
+	url = https://github.com/g-truc/glm.git

glm @ 6a1e2ec5

+Subproject commit 6a1e2ec5d5e79e6d869c947cbdbcbb297bdf9d32

3rdparty/glm-0.9.7.0/copying.txt

-================================================================================
-OpenGL Mathematics (GLM)
---------------------------------------------------------------------------------
-GLM can be distributed and/or modified under the terms of either
-a) The Happy Bunny License, or b) the MIT License.
-
-================================================================================
-The Happy Bunny License (Modified MIT License)
---------------------------------------------------------------------------------
-Copyright (c) 2005 - 2015 G-Truc Creation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-Restrictions: By making use of the Software for military purposes, you choose
-to make a Bunny unhappy.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-================================================================================
-The MIT License
---------------------------------------------------------------------------------
-Copyright (c) 2005 - 2015 G-Truc Creation
-
-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.

3rdparty/glm-0.9.7.0/glm/CMakeLists.txt

-set(NAME glm_dummy)
-
-file(GLOB ROOT_SOURCE *.cpp)
-file(GLOB ROOT_INLINE *.inl)
-file(GLOB ROOT_HEADER *.hpp)
-file(GLOB ROOT_TEXT ../*.txt)
-file(GLOB ROOT_MD ../*.md)
-file(GLOB ROOT_NAT ../util/glm.natvis)
-
-file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
-file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
-file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
-
-file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
-file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
-file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
-
-file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
-file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
-file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
-
-source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD})
-source_group("Core Files" FILES ${CORE_SOURCE})
-source_group("Core Files" FILES ${CORE_INLINE})
-source_group("Core Files" FILES ${CORE_HEADER})
-source_group("GTC Files" FILES ${GTC_SOURCE})
-source_group("GTC Files" FILES ${GTC_INLINE})
-source_group("GTC Files" FILES ${GTC_HEADER})
-source_group("GTX Files" FILES ${GTX_SOURCE})
-source_group("GTX Files" FILES ${GTX_INLINE})
-source_group("GTX Files" FILES ${GTX_HEADER})
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-if(GLM_TEST_ENABLE)
-	add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
-endif(GLM_TEST_ENABLE)
-
-#add_library(glm STATIC glm.cpp)
-#add_library(glm_shared SHARED glm.cpp)

3rdparty/glm-0.9.7.0/glm/common.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/common.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "detail/func_common.hpp"

3rdparty/glm-0.9.7.0/glm/detail/_fixes.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/_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
-

3rdparty/glm-0.9.7.0/glm/detail/_noise.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/_noise.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "../vec2.hpp"
-#include "../vec3.hpp"
-#include "../vec4.hpp"
-#include "../common.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER T mod289(T const & x)
-	{
-		return x - floor(x * static_cast<T>(1.0) / static_cast<T>(289.0)) * static_cast<T>(289.0);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T permute(T const & x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-/*
-	template <typename T, precision P, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
-	{
-		return mod289(((x * T(34)) + T(1)) * x);
-	}
-*/
-	template <typename T>
-	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-/*
-	template <typename T, precision P, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-*/
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-/*
-	template <typename T, precision P, template <typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-*/
-}//namespace detail
-}//namespace glm
-

3rdparty/glm-0.9.7.0/glm/detail/_vectorize.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/_vectorize.hpp
-/// @date 2011-10-14 / 2011-10-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename R, typename T, precision P, template <typename, precision> class vecType>
-	struct functor1{};
-
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec1>
-	{
-		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
-		{
-			return tvec1<R, P>(Func(v.x));
-		}
-	};
-
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec2>
-	{
-		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
-		{
-			return tvec2<R, P>(Func(v.x), Func(v.y));
-		}
-	};
-
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec3>
-	{
-		GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
-		{
-			return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
-		}
-	};
-
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
-		{
-			return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	struct functor2{};
-
-	template <typename T, precision P>
-	struct functor2<T, P, tvec1>
-	{
-		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
-		{
-			return tvec1<T, P>(Func(a.x, b.x));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2<T, P, tvec2>
-	{
-		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
-		{
-			return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2<T, P, tvec3>
-	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
-		{
-			return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2<T, P, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
-		{
-			return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	struct functor2_vec_sca{};
-
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec1>
-	{
-		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
-		{
-			return tvec1<T, P>(Func(a.x, b));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec2>
-	{
-		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
-		{
-			return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec3>
-	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
-		{
-			return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
-		}
-	};
-
-	template <typename T, precision P>
-	struct functor2_vec_sca<T, P, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
-		{
-			return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
-		}
-	};
-}//namespace detail
-}//namespace glm

3rdparty/glm-0.9.7.0/glm/detail/dummy.cpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref 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/glm.hpp>
-#include <glm/ext.hpp>
-#include <limits>
-
-struct material
-{
-	glm::vec4 emission; // Ecm
-	glm::vec4 ambient; // Acm
-	glm::vec4 diffuse; // Dcm
-	glm::vec4 specular; // Scm
-	float shininess; // Srm
-};
-
-struct light
-{
-	glm::vec4 ambient; // Acli
-	glm::vec4 diffuse; // Dcli
-	glm::vec4 specular; // Scli
-	glm::vec4 position; // Ppli
-	glm::vec4 halfVector; // Derived: Hi
-	glm::vec3 spotDirection; // Sdli
-	float spotExponent; // Srli
-	float spotCutoff; // Crli
-	// (range: [0.0,90.0], 180.0)
-	float spotCosCutoff; // Derived: cos(Crli)
-	// (range: [1.0,0.0],-1.0)
-	float constantAttenuation; // K0
-	float linearAttenuation; // K1
-	float quadraticAttenuation;// K2
-};
-
-
-// Sample 1
-#include <glm/vec3.hpp>// glm::vec3
-#include <glm/geometric.hpp>// glm::cross, glm::normalize
-
-glm::vec3 computeNormal
-(
-	glm::vec3 const & a,
-	glm::vec3 const & b,
-	glm::vec3 const & c
-)
-{
-	return glm::normalize(glm::cross(c - a, b - a));
-}
-
-typedef unsigned int GLuint;
-#define GL_FALSE 0
-void glUniformMatrix4fv(GLuint, int, int, float*){}
-
-// Sample 2
-#include <glm/vec3.hpp> // glm::vec3
-#include <glm/vec4.hpp> // glm::vec4, glm::ivec4
-#include <glm/mat4x4.hpp> // glm::mat4
-#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
-#include <glm/gtc/type_ptr.hpp> // glm::value_ptr
-void func(GLuint LocationMVP, float Translate, glm::vec2 const & Rotate)
-{
-	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
-	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
-	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
-	glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
-	glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
-	glm::mat4 MVP = Projection * View * Model;
-	glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP));
-}
-
-// Sample 3
-#include <glm/vec2.hpp>// glm::vec2
-#include <glm/packing.hpp>// glm::packUnorm2x16
-#include <glm/integer.hpp>// glm::uint
-#include <glm/gtc/type_precision.hpp>// glm::i8vec2, glm::i32vec2
-std::size_t const VertexCount = 4;
-// Float quad geometry
-std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
-glm::vec2 const PositionDataF32[VertexCount] =
-{
-	glm::vec2(-1.0f,-1.0f),
-	glm::vec2( 1.0f,-1.0f),
-	glm::vec2( 1.0f, 1.0f),
-	glm::vec2(-1.0f, 1.0f)
-	};
-// Half-float quad geometry
-std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint);
-glm::uint const PositionDataF16[VertexCount] =
-{
-	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f)))
-};
-// 8 bits signed integer quad geometry
-std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
-glm::i8vec2 const PositionDataI8[VertexCount] =
-{
-	glm::i8vec2(-1,-1),
-	glm::i8vec2( 1,-1),
-	glm::i8vec2( 1, 1),
-	glm::i8vec2(-1, 1)
-};
-// 32 bits signed integer quad geometry
-std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
-glm::i32vec2 const PositionDataI32[VertexCount] =
-{
-	glm::i32vec2 (-1,-1),
-	glm::i32vec2 ( 1,-1),
-	glm::i32vec2 ( 1, 1),
-	glm::i32vec2 (-1, 1)
-};
-
-struct intersection
-{
-	glm::vec4 position;
-	glm::vec3 normal;
-};
-
-/*
-// Sample 4
-#include <glm/vec3.hpp>// glm::vec3
-#include <glm/geometric.hpp>// glm::normalize, glm::dot, glm::reflect
-#include <glm/exponential.hpp>// glm::pow
-#include <glm/gtc/random.hpp>// glm::vecRand3
-glm::vec3 lighting
-(
-	intersection const & Intersection,
-	material const & Material,
-	light const & Light,
-	glm::vec3 const & View
-)
-{
-	glm::vec3 Color(0.0f);
-	glm::vec3 LightVertor(glm::normalize(
-		Light.position - Intersection.position +
-		glm::vecRand3(0.0f, Light.inaccuracy));
-
-	if(!shadow(Intersection.position, Light.position, LightVertor))
-	{
-		float Diffuse = glm::dot(Intersection.normal, LightVector);
-		if(Diffuse <= 0.0f)
-			return Color;
-		if(Material.isDiffuse())
-			Color += Light.color() * Material.diffuse * Diffuse;
-		if(Material.isSpecular())
-		{
-			glm::vec3 Reflect(glm::reflect(
-				glm::normalize(-LightVector),
-				glm::normalize(Intersection.normal)));
-			float Dot = glm::dot(Reflect, View);
-			float Base = Dot > 0.0f ? Dot : 0.0f;
-			float Specular = glm::pow(Base, Material.exponent);
-			Color += Material.specular * Specular;
-		}
-	}
-	return Color;
-}
-*/
-
-
-template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
-T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
-{
-	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
-}
-
-#define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template<typename, glm::precision> class
-
-template <GLM_TEMPLATE_GENTYPE vecType>
-T normalizeDotB(vecType<T, P> const & x, vecType<T, P> const & y)
-{
-	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
-}
-
-template <typename vecType>
-typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
-{
-	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
-}
-
-int main()
-{
-	glm::vec1 o(1);
-	glm::vec2 a(1);
-	glm::vec3 b(1);
-	glm::vec4 c(1);
-
-	glm::quat q;
-	glm::dualquat p;
-
-	glm::mat4 m(1);
-
-	float a0 = normalizeDotA(a, a);
-	float b0 = normalizeDotB(b, b);
-	float c0 = normalizeDotC(c, c);
-
-	return 0;
-}

3rdparty/glm-0.9.7.0/glm/detail/func_exponential.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-#include <cmath>
-
-namespace glm
-{
-	/// @addtogroup core_func_exponential
-	/// @{
-
-	/// Returns 'base' raised to the power 'exponent'. 
-	///
-	/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
-	/// @param exponent Floating point value representing the 'exponent'.
-	/// @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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent);
-
-	/// Returns the natural exponentiation of x, i.e., e^x.
-	///
-	/// @param v exp function is defined for input values of v 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
-
-	/// Returns the natural logarithm of v, i.e., 
-	/// returns the value y which satisfies the equation x = e^y. 
-	/// Results are undefined if v <= 0.
-	///
-	/// @param v log function is defined for input values of v 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
-
-	/// Returns 2 raised to the v power.
-	/// 
-	/// @param v exp2 function is defined for input values of v 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> exp2(vecType<T, P> const & v);
-
-	/// Returns the base 2 log of x, i.e., returns the value y, 
-	/// which satisfies the equation x = 2 ^ y.
-	/// 
-	/// @param v log2 function is defined for input values of v 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
-
-	/// Returns the positive square root of v.
-	/// 
-	/// @param v sqrt function is defined for input values of v 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>
-	//GLM_FUNC_DECL genType sqrt(genType const & x);
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
-	
-	/// Returns the reciprocal of the positive square root of v.
-	/// 
-	/// @param v inversesqrt function is defined for input values of v 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> inversesqrt(vecType<T, P> const & v);
-
-	/// @}
-}//namespace glm
-
-#include "func_exponential.inl"

3rdparty/glm-0.9.7.0/glm/detail/func_exponential.inl

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "func_vector_relational.hpp"
-#include "_vectorize.hpp"
-#include <limits>
-#include <cmath>
-#include <cassert>
-
-namespace glm{
-namespace detail
-{
-#	if GLM_HAS_CXX11_STL
-		using std::log2;
-#	else
-		template <typename genType>
-		genType log2(genType Value)
-		{
-			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
-		}
-#	endif
-
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
-	struct compute_log2
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
-		{
-			return detail::functor1<T, T, P, vecType>::call(log2, vec);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P>
-	struct compute_inversesqrt
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return static_cast<T>(1) / sqrt(x);
-		}
-	};
-		
-	template <template <class, precision> class vecType>
-	struct compute_inversesqrt<vecType, float, lowp>
-	{
-		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
-		{
-			vecType<float, lowp> tmp(x);
-			vecType<float, lowp> xhalf(tmp * 0.5f);
-			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
-			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
-			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
-			tmp = *ptmp;
-			tmp = tmp * (1.5f - xhalf * tmp * tmp);
-			return tmp;
-		}
-	};
-}//namespace detail
-
-	// pow
-	using std::pow;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
-	{
-		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
-	}
-
-	// exp
-	using std::exp;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(exp, x);
-	}
-
-	// log
-	using std::log;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(log, x);
-	}
-
-	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
-
-		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(exp2, x);
-	}
-
-	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log2(genType x)
-	{
-		return log2(tvec1<genType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
-	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
-	}
-
-	// sqrt
-	using std::sqrt;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
-	}
-
-	// inversesqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
-	{
-		return static_cast<genType>(1) / sqrt(x);
-	}
-	
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P>::call(x);
-	}
-}//namespace glm

3rdparty/glm-0.9.7.0/glm/detail/func_geometric.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "type_vec3.hpp"
-
-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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T length(
-		vecType<T, P> 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T distance(
-		vecType<T, P> const & p0,
-		vecType<T, P> 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T dot(
-		vecType<T, P> const & x,
-		vecType<T, P> 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 T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> cross(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y);
-
-	/// Returns a vector in the same direction as x but with length of 1.
-	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
-	/// 
-	/// @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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> normalize(
-		vecType<T, P> 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> faceforward(
-		vecType<T, P> const & N,
-		vecType<T, P> const & I,
-		vecType<T, P> 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>
-	GLM_FUNC_DECL 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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> refract(
-		vecType<T, P> const & I,
-		vecType<T, P> const & N,
-		T eta);
-
-	/// @}
-}//namespace glm
-
-#include "func_geometric.inl"

3rdparty/glm-0.9.7.0/glm/detail/func_geometric.inl

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/func_geometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "func_exponential.hpp"
-#include "func_common.hpp"
-#include "type_vec2.hpp"
-#include "type_vec4.hpp"
-#include "type_float.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <template <class, precision> class vecType, typename T, precision P>
-	struct compute_dot{};
-
-	template <typename T, precision P>
-	struct compute_dot<tvec1, T, P>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
-		{
-			return a.x * b.x;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_dot<tvec2, T, P>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
-		{
-			tvec2<T, P> tmp(x * y);
-			return tmp.x + tmp.y;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_dot<tvec3, T, P>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
-		{
-			tvec3<T, P> tmp(x * y);
-			return tmp.x + tmp.y + tmp.z;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_dot<tvec4, T, P>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
-		{
-			tvec4<T, P> tmp(x * y);
-			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
-		}
-	};
-}//namespace detail
-
-	// length
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
-
-		return abs(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
-
-		return sqrt(dot(v, v));
-	}
-
-	// distance
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
-	{
-		return length(p1 - p0);
-	}
-
-	// dot
-	template <typename T>
-	GLM_FUNC_QUALIFIER T dot(T x, T y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return x * y;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return detail::compute_dot<vecType, T, P>::call(x, y);
-	}
-
-	// cross
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
-
-		return tvec3<T, P>(
-			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(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
-
-		return x < genType(0) ? genType(-1) : genType(1);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
-
-		return x * inversesqrt(dot(x, x));
-	}
-
-	// faceforward
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
-	{
-		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> faceforward(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
-	{
-		return dot(Nref, I) < static_cast<T>(0) ? N : -N;
-	}
-
-	// reflect
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
-	{
-		return I - N * dot(N, I) * static_cast<genType>(2);
-	}
-
-	// refract
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
-
-		genType const dotValue(dot(N, I));
-		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
-
-		T const dotValue(dot(N, I));
-		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
-	}
-}//namespace glm

3rdparty/glm-0.9.7.0/glm/detail/func_matrix.hpp

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-// Dependencies
-#include "../detail/precision.hpp"
-#include "../detail/setup.hpp"
-#include "../detail/type_mat.hpp"
-#include "../vec2.hpp"
-#include "../vec3.hpp"
-#include "../vec4.hpp"
-#include "../mat2x2.hpp"
-#include "../mat2x3.hpp"
-#include "../mat2x4.hpp"
-#include "../mat3x2.hpp"
-#include "../mat3x3.hpp"
-#include "../mat3x4.hpp"
-#include "../mat4x2.hpp"
-#include "../mat4x3.hpp"
-#include "../mat4x4.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec2>
-	{
-		typedef tmat2x2<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec3>
-	{
-		typedef tmat2x3<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec2, tvec4>
-	{
-		typedef tmat2x4<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec2>
-	{
-		typedef tmat3x2<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec3>
-	{
-		typedef tmat3x3<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec3, tvec4>
-	{
-		typedef tmat3x4<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec2>
-	{
-		typedef tmat4x2<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec3>
-	{
-		typedef tmat4x3<T, P> type;
-	};
-
-	template <typename T, precision P>
-	struct outerProduct_trait<T, P, tvec4, tvec4>
-	{
-		typedef tmat4x4<T, P> type;
-	};
-
-}//namespace detail
-
-	/// @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 T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> 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>
-	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
-	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> 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>
-#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
-		template <typename T, precision P, template <typename, precision> class matType>
-		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
-#	endif
-	
-	/// Return the determinant of a squared 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 T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_DECL T determinant(matType<T, P> const & m);
-
-	/// Return the inverse of a squared 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 T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
-
-	/// @}
-}//namespace glm
-
-#include "func_matrix.inl"

3rdparty/glm-0.9.7.0/glm/detail/intrinsic_exponential.inl

-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// 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/detail/intrinsic_exponential.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////