Skip to content

C
CGoGN
Commit aac662e8 authored by Sylvain Thery's avatar Sylvain Thery
Browse files
Options

update glm of ThirdParty

parent f608c3d9
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 53449 additions and 36337 deletions
CMakeLists.txt
View file @ aac662e8
......@@ -84,6 +84,7 @@ ENDIF (WITH_GLEWMX)
add_definitions(-DSHADERPATH="${CGoGN_ROOT_DIR}/lib/Shaders/")
add_definitions(-DGLM_FORCE_RADIANS)
# define includes of external libs
SET (CGoGN_EXT_INCLUDES
......
SCHNApps/CMakeLists.txt
View file @ aac662e8
......@@ -39,6 +39,7 @@ SET( QT_USE_QTSVG TRUE )
INCLUDE(${QT_USE_FILE})
ADD_DEFINITIONS(${QT_DEFINITIONS})
add_definitions(-DGLM_FORCE_RADIANS)
#MESSAGE HERE FOR MORE EASY READING (MESSAGE AT THE END)
MESSAGE("Build type = " ${CMAKE_BUILD_TYPE} " (for change -DCMAKE_BUILD_TYPE=Release|Debug)" )
......
ThirdParty/include/glm/CMakeLists.txt 0 → 100644
View file @ aac662e8
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_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})
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_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)
ThirdParty/include/glm/common.hpp 0 → 100644
View file @ aac662e8
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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/common.hpp
/// @date 2013-12-24 / 2013-12-24
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_COMMON_INCLUDED
#define GLM_COMMON_INCLUDED
#include "detail/func_common.hpp"
#endif//GLM_COMMON_INCLUDED
ThirdParty/include/glm/core/_detail.hpp deleted 100644 → 0
View file @ f608c3d9
///////////////////////////////////////////////////////////////////////////////////////////////////
// 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/include/glm/core/_swizzle.hpp deleted 100644 → 0
View file @ f608c3d9
This diff is collapsed.
ThirdParty/include/glm/core/_swizzle.inl deleted 100644 → 0
View file @ f608c3d9
///////////////////////////////////////////////////////////////////////////////////////////////////
// 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/include/glm/core/dummy.cpp deleted 100644 → 0
View file @ f608c3d9
///////////////////////////////////////////////////////////////////////////////////////////////////
// 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/include/glm/core/func_common.hpp deleted 100644 → 0
View file @ f608c3d9
This diff is collapsed.
ThirdParty/include/glm/core/func_common.inl deleted 100644 → 0
View file @ f608c3d9
This diff is collapsed.
ThirdParty/include/glm/core/func_exponential.hpp deleted 100644 → 0
View file @ f608c3d9
///////////////////////////////////////////////////////////////////////////////////////////////////
// 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/include/glm/core/func_exponential.inl deleted 100644 → 0
View file @ f608c3d9
///////////////////////////////////////////////////////////////////////////////////////////////////
// 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);
}