Parallelisation d'algorithme et foreach

ajout de GLM pour GL3 (bientot !)

Apps/Tuto/CMakeLists.txt

@@ -5,8 +5,8 @@ project(Tutos)
 #SET (COMMON_LIBS ${GLUT_LIBRARY} ${OPENGL_LIBRARY} ${GLEW_LIBRARY} ${DEVIL_LIBRARIES} ${ZLIB_LIBRARIES} ${LIBXML2_LIBRARIES} gzstream AntTweakBar openctm)
 
 
-#SET (CMAKE_BUILD_TYPE Debug)
-SET(CMAKE_BUILD_TYPE Release)
+SET (CMAKE_BUILD_TYPE Debug)
+#SET(CMAKE_BUILD_TYPE Release)
 
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOTOPOWARNING")
 
@@ -54,5 +54,5 @@ target_link_libraries( tp_master
 
 add_executable( tuto_mt tuto_mt.cpp)
 target_link_libraries( tuto_mt
-#	containerD topologyD utilsD algoD  ${COMMON_LIBS} boost_thread)
-	container topology utils algo ${COMMON_LIBS} boost_thread)
+	containerD topologyD utilsD algoD  ${COMMON_LIBS} boost_thread)
+#	container topology utils algo ${COMMON_LIBS} boost_thread)

Apps/Tuto/tp_master.cpp

@@ -635,7 +635,6 @@ void myGlutWin::myKeyboard(unsigned char keycode, int x, int y)
 		/// calcul du rayon
 		getOrthoScreenRay(x,y,rayA,rayB);
 		PFP::VEC3 AB = rayB-rayA;
-		float AB2 = AB.norm2();
 
 		d_faces.clear();
 		d_edges.clear();
@@ -679,7 +678,6 @@ void myGlutWin::myKeyboard(unsigned char keycode, int x, int y)
 		/// Rayon
 		getOrthoScreenRay(x,y,rayA,rayB);
 		PFP::VEC3 AB = rayB-rayA;
-		float AB2 = AB.norm2();
 
 		d_faces.clear();
 		d_edges.clear();

ThirdParty/glm/glm/core/_detail.hpp

+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-07-24
+// Updated : 2008-08-31
+// Licence : This source is under MIT License
+// File    : glm/core/_detail.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_detail
+#define glm_core_detail
+
+#include "../setup.hpp"
+#include <cassert>
+
+namespace glm{
+namespace detail{
+
+	class thalf;
+
+#if(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_VC))
+	typedef signed __int64						sint64;
+	typedef unsigned __int64					uint64;
+#elif(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_GCC))
+	__extension__ typedef signed long long		sint64;
+	__extension__ typedef unsigned long long	uint64;
+#else//unknown compiler
+	typedef signed long							sint64;
+	typedef unsigned long						uint64;
+#endif//GLM_COMPILER
+
+	template<bool C>
+	struct If
+	{
+		template<typename F, typename T>
+		static inline T apply(F functor, const T& val)
+		{
+			return functor(val);
+		}
+	};
+
+	template<>
+	struct If<false>
+	{
+		template<typename F, typename T>
+		static inline T apply(F, const T& val)
+		{
+			return val;
+		}
+	};
+
+	//template <typename T>
+	//struct traits
+	//{
+	//	static const bool is_signed = false;
+	//	static const bool is_float = false;
+	//	static const bool is_vector = false;
+	//	static const bool is_matrix = false;
+	//	static const bool is_genType = false;
+	//	static const bool is_genIType = false;
+	//	static const bool is_genUType = false;
+	//};
+
+	//template <>
+	//struct traits<half>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<float>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<double>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <typename genType>
+	//struct desc
+	//{
+	//	typedef genType							type;
+	//	typedef genType *						pointer;
+	//	typedef genType const*					const_pointer;
+	//	typedef genType const *const			const_pointer_const;
+	//	typedef genType *const					pointer_const;
+	//	typedef genType &						reference;
+	//	typedef genType const&					const_reference;
+	//	typedef genType const&					param_type;
+
+	//	typedef typename genType::value_type	value_type;
+	//	typedef typename genType::size_type		size_type;
+	//	static const typename size_type			value_size;
+	//};
+
+	//template <typename genType>
+	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
+
+	union uif32
+	{
+		uif32() :
+			i(0)
+		{}
+
+		uif32(float f) :
+			f(f)
+		{}
+
+		uif32(unsigned int i) :
+			i(i)
+		{}
+
+		float f;
+		unsigned int i;
+	};
+
+	union uif64
+	{
+		uif64() :
+			i(0)
+		{}
+
+		uif64(double f) :
+			f(f)
+		{}
+
+		uif64(uint64 i) :
+			i(i)
+		{}
+
+		double f;
+		uint64 i;
+	};
+
+	typedef uif32 uif;
+
+	//////////////////
+	// int
+
+	template <typename T>
+	struct is_int
+	{
+		enum is_int_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_INT(T)	\
+	template <>					\
+	struct is_int<T>			\
+	{							\
+		enum is_int_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// uint
+
+	template <typename T>
+	struct is_uint
+	{
+		enum is_uint_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_UINT(T)	\
+	template <>					\
+	struct is_uint<T>			\
+	{							\
+		enum is_uint_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//GLM_DETAIL_IS_UINT(unsigned long long)
+
+	//////////////////
+	// float
+
+	template <typename T>
+	struct is_float
+	{
+		enum is_float_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_FLOAT(T)	\
+	template <>					\
+	struct is_float<T>			\
+	{							\
+		enum is_float_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// bool
+
+	template <typename T>
+	struct is_bool
+	{
+		enum is_bool_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+	
+	template <>
+	struct is_bool<bool>
+	{
+		enum is_bool_enum
+		{
+			_YES = 1,
+			_NO = 0
+		};
+	};
+	
+	//////////////////
+	// vector
+
+	template <typename T>
+	struct is_vector
+	{
+		enum is_vector_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_VECTOR(T)	\
+	template <>					\
+	struct is_vector			\
+	{							\
+		enum is_vector_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// matrix
+
+	template <typename T>
+	struct is_matrix
+	{
+		enum is_matrix_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_MATRIX(T)	\
+	template <>					\
+	struct is_matrix			\
+	{							\
+		enum is_matrix_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// type
+
+	template <typename T>
+	struct type
+	{
+		enum type_enum
+		{
+			is_float = is_float<T>::_YES,
+			is_int = is_int<T>::_YES,
+			is_uint = is_uint<T>::_YES,
+			is_bool = is_bool<T>::_YES
+		};
+	};
+
+	//////////////////
+	// type
+
+	typedef signed char							int8;
+	typedef signed short						int16;
+	typedef signed int							int32;
+	typedef detail::sint64						int64;
+
+	typedef unsigned char						uint8;
+	typedef unsigned short						uint16;
+	typedef unsigned int						uint32;
+	typedef detail::uint64						uint64;
+
+	typedef detail::thalf						float16;
+	typedef float								float32;
+	typedef double								float64;
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_detail

ThirdParty/glm/glm/core/_swizzle.inl

+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-27
+// Updated : 2006-04-27
+// Licence : This source is under MIT License
+// File    : _swizzle.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __swizzle_inl__
+#define __swizzle_inl__
+
+#include "./_swizzle.h"
+
+namespace glm
+{
+
+}
+
+#endif//__swizzle_inl__

ThirdParty/glm/glm/core/dummy.cpp

+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-01-19
+// Updated : 2011-01-19
+// Licence : This source is under MIT License
+// File    : glm/setup.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dummy file, GLM is a header only library
+
+#include "../glm.hpp"
+#include "../ext.hpp"
+
+int main()
+{
+
+}

ThirdParty/glm/glm/core/func_exponential.hpp

+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-08
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_exponential
+#define glm_core_func_exponential
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_exponential();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace exponential{
+
+	//! Returns x raised to the y power. 
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType pow(genType const & x, genType const & y);
+
+	//! Returns the natural exponentiation of x, i.e., e^x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	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.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType log(genType const & x);
+
+	//! Returns 2 raised to the x power.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	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.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType log2(genType const & x);
+
+	//! Returns the positive square root of x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType sqrt(genType const & x);
+    
+	//! Returns the reciprocal of the positive square root of x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType inversesqrt(genType const & x);
+
+	}//namespace exponential
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::exponential;
+}//namespace glm
+
+#include "func_exponential.inl"
+
+#endif//glm_core_func_exponential

ThirdParty/glm/glm/core/func_exponential.inl

+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace exponential{
+
+    // pow
+    template <typename genType>
+    inline genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::pow(x, y);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> pow
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> pow
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> pow
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+        return detail::tvec4<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z),
+            pow(x.w, y.w));
+    }
+
+    // exp
+    template <typename genType>
+    inline genType exp
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::exp(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> exp
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            exp(x.x),
+            exp(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> exp
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> exp
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z),
+            exp(x.w));
+    }
+
+    // log
+    template <typename genType>
+    inline genType log
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::log(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> log
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            log(x.x),
+            log(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> log
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            log(x.x),
+            log(x.y),
+            log(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> log
+	(
+		detail::tvec4<T> const & x
+	)