diff --git a/glm/ext.hpp b/glm/ext.hpp index 59d70512..283279ce 100644 --- a/glm/ext.hpp +++ b/glm/ext.hpp @@ -62,8 +62,10 @@ # pragma message("GLM: All extensions included (not recommanded)") #endif//GLM_MESSAGES +#include "./gtc/bitfield.hpp" #include "./gtc/constants.hpp" #include "./gtc/epsilon.hpp" +#include "./gtc/integer.hpp" #include "./gtc/matrix_access.hpp" #include "./gtc/matrix_integer.hpp" #include "./gtc/matrix_inverse.hpp" @@ -73,6 +75,7 @@ #include "./gtc/quaternion.hpp" #include "./gtc/random.hpp" #include "./gtc/reciprocal.hpp" +#include "./gtc/round.hpp" #include "./gtc/type_precision.hpp" #include "./gtc/type_ptr.hpp" #include "./gtc/ulp.hpp" @@ -104,7 +107,6 @@ #include "./gtx/matrix_operation.hpp" #include "./gtx/matrix_query.hpp" #include "./gtx/mixed_product.hpp" -#include "./gtx/multiple.hpp" #include "./gtx/norm.hpp" #include "./gtx/normal.hpp" #include "./gtx/normalize_dot.hpp" diff --git a/glm/gtc/bitfield.hpp b/glm/gtc/bitfield.hpp index 1dff5e82..82f056c8 100644 --- a/glm/gtc/bitfield.hpp +++ b/glm/gtc/bitfield.hpp @@ -20,7 +20,7 @@ /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. /// -/// @ref gtc_bit +/// @ref gtc_bitfield /// @file glm/gtc/bitfield.hpp /// @date 2014-10-25 / 2014-10-25 /// @author Christophe Riccio diff --git a/glm/gtc/round.hpp b/glm/gtc/round.hpp new file mode 100644 index 00000000..9e8eee77 --- /dev/null +++ b/glm/gtc/round.hpp @@ -0,0 +1,199 @@ +/////////////////////////////////////////////////////////////////////////////////// +/// 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 gtc_round +/// @file glm/gtc/round.hpp +/// @date 2014-11-03 / 2014-11-03 +/// @author Christophe Riccio +/// +/// @see core (dependence) +/// @see gtc_round (dependence) +/// +/// @defgroup gtc_round GLM_GTC_round +/// @ingroup gtc +/// +/// @brief rounding value to specific boundings +/// +/// need to be included to use these functionalities. +/////////////////////////////////////////////////////////////////////////////////// + +#pragma once + +// Dependencies +#include "../detail/setup.hpp" +#include "../detail/precision.hpp" +#include "../detail/_vectorize.hpp" +#include "../vector_relational.hpp" +#include "../common.hpp" +#include + +#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED)) +# pragma message("GLM: GLM_GTC_integer extension included") +#endif + +namespace glm +{ + /// @addtogroup gtc_round + /// @{ + + /// Return true if the value is a power of two number. + /// + /// @see gtc_round + template + GLM_FUNC_DECL bool isPowerOfTwo(genIUType Value); + + /// Return true if the value is a power of two number. + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType isPowerOfTwo(vecType const & value); + + /// Return the power of two number which value is just higher the input value, + /// round up to a power of two. + /// + /// @see gtc_round + template + GLM_FUNC_DECL genIUType ceilPowerOfTwo(genIUType Value); + + /// Return the power of two number which value is just higher the input value, + /// round up to a power of two. + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType ceilPowerOfTwo(vecType const & value); + + /// Return the power of two number which value is just lower the input value, + /// round down to a power of two. + /// + /// @see gtc_round + template + GLM_FUNC_DECL genIUType floorPowerOfTwo(genIUType Value); + + /// Return the power of two number which value is just lower the input value, + /// round down to a power of two. + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType floorPowerOfTwo(vecType const & value); + + /// Return the power of two number which value is the closet to the input value. + /// + /// @see gtc_round + template + GLM_FUNC_DECL genIUType roundPowerOfTwo(genIUType Value); + + /// Return the power of two number which value is the closet to the input value. + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType roundPowerOfTwo(vecType const & value); + + /// Return true if the is a multiple of . + /// + /// @see gtc_round + template + GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple); + + /// Return true if the is a multiple of . + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType isMultiple(vecType const & Value, T Multiple); + + /// Return true if the is a multiple of . + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType isMultiple(vecType const & Value, vecType const & Multiple); + + /// Higher multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template + GLM_FUNC_DECL genType ceilMultiple(genType Source, genType Multiple); + + /// Higher multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType ceilMultiple(vecType const & Source, vecType const & Multiple); + + /// Lower multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template + GLM_FUNC_DECL genType floorMultiple( + genType Source, + genType Multiple); + + /// Lower multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType floorMultiple( + vecType const & Source, + vecType const & Multiple); + + /// Lower multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template + GLM_FUNC_DECL genType roundMultiple( + genType Source, + genType Multiple); + + /// Lower multiple number of Source. + /// + /// @tparam genType Floating-point or integer scalar or vector types. + /// @param Source + /// @param Multiple Must be a null or positive value + /// + /// @see gtc_round + template class vecType> + GLM_FUNC_DECL vecType roundMultiple( + vecType const & Source, + vecType const & Multiple); + + /// @} +} //namespace glm + +#include "round.inl" diff --git a/glm/gtc/round.inl b/glm/gtc/round.inl new file mode 100644 index 00000000..bc911ee6 --- /dev/null +++ b/glm/gtc/round.inl @@ -0,0 +1,374 @@ +/////////////////////////////////////////////////////////////////////////////////// +/// 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 gtc_round +/// @file glm/gtc/round.inl +/// @date 2014-11-03 / 2014-11-03 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +namespace glm +{ +namespace detail +{ + template class vecType, bool compute = false> + struct compute_ceilShift + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v, T) + { + return v; + } + }; + + template class vecType> + struct compute_ceilShift + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v, T Shift) + { + return v | (v >> Shift); + } + }; + + template class vecType, bool isSigned = true> + struct compute_ceilPowerOfTwo + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & x) + { + GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); + + vecType const Sign(sign(x)); + + vecType v(abs(x)); + + v = v - static_cast(1); + v = v | (v >> static_cast(1)); + v = v | (v >> static_cast(2)); + v = v | (v >> static_cast(4)); + v = compute_ceilShift= 2>::call(v, 8); + v = compute_ceilShift= 4>::call(v, 16); + v = compute_ceilShift= 8>::call(v, 32); + return (v + static_cast(1)) * Sign; + } + }; + + template class vecType> + struct compute_ceilPowerOfTwo + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & x) + { + GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); + + vecType v(x); + + v = v - static_cast(1); + v = v | (v >> static_cast(1)); + v = v | (v >> static_cast(2)); + v = v | (v >> static_cast(4)); + v = compute_ceilShift= 2>::call(v, 8); + v = compute_ceilShift= 4>::call(v, 16); + v = compute_ceilShift= 8>::call(v, 32); + return v + static_cast(1); + } + }; + + template + struct compute_ceilMultiple{}; + + template <> + struct compute_ceilMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source > genType(0)) + { + genType Tmp = Source - genType(1); + return Tmp + (Multiple - std::fmod(Tmp, Multiple)); + } + else + return Source + std::fmod(-Source, Multiple); + } + }; + + template <> + struct compute_ceilMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + genType Tmp = Source - genType(1); + return Tmp + (Multiple - (Tmp % Multiple)); + } + }; + + template <> + struct compute_ceilMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source > genType(0)) + { + genType Tmp = Source - genType(1); + return Tmp + (Multiple - (Tmp % Multiple)); + } + else + return Source + (-Source % Multiple); + } + }; + + template + struct compute_floorMultiple{}; + + template <> + struct compute_floorMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - std::fmod(Source, Multiple); + else + { + genType Tmp = Source + genType(1); + return Tmp - std::fmod(Tmp, Multiple) - Multiple; + } + } + }; + + template <> + struct compute_floorMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - Source % Multiple; + else + { + genType Tmp = Source + genType(1); + return Tmp - Tmp % Multiple - Multiple; + } + } + }; + + template <> + struct compute_floorMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - Source % Multiple; + else + { + genType Tmp = Source + genType(1); + return Tmp - Tmp % Multiple - Multiple; + } + } + }; + + template + struct compute_roundMultiple{}; + + template <> + struct compute_roundMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - std::fmod(Source, Multiple); + else + { + genType Tmp = Source + genType(1); + return Tmp - std::fmod(Tmp, Multiple) - Multiple; + } + } + }; + + template <> + struct compute_roundMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - Source % Multiple; + else + { + genType Tmp = Source + genType(1); + return Tmp - Tmp % Multiple - Multiple; + } + } + }; + + template <> + struct compute_roundMultiple + { + template + GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) + { + if(Source >= genType(0)) + return Source - Source % Multiple; + else + { + genType Tmp = Source + genType(1); + return Tmp - Tmp % Multiple - Multiple; + } + } + }; +}//namespace detail + + //////////////// + // isPowerOfTwo + + template + GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value) + { + genType const Result = glm::abs(Value); + return !(Result & (Result - 1)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType isPowerOfTwo(vecType const & Value) + { + vecType const Result(abs(Value)); + return equal(Result & (Result - 1), vecType(0)); + } + + ////////////////// + // ceilPowerOfTwo + + template + GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value) + { + return detail::compute_ceilPowerOfTwo::is_signed>::call(tvec1(value)).x; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType ceilPowerOfTwo(vecType const & v) + { + return detail::compute_ceilPowerOfTwo::is_signed>::call(v); + } + + /////////////////// + // floorPowerOfTwo + + template + GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value) + { + return isPowerOfTwo(value) ? value : highestBitValue(value); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType floorPowerOfTwo(vecType const & v) + { + return detail::functor1::call(floorPowerOfTwo, v); + } + + /////////////////// + // roundPowerOfTwo + + template + GLM_FUNC_QUALIFIER genType roundPowerOfTwo(genType value) + { + if(isPowerOfTwo(value)) + return value; + + genType const prev = highestBitValue(value); + genType const next = prev << 1; + return (next - value) < (value - prev) ? next : prev; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType roundPowerOfTwo(vecType const & v) + { + return detail::functor1::call(roundPowerOfTwo, v); + } + + //////////////// + // isMultiple + + template + GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple) + { + return isMultiple(tvec1(Value), tvec1(Multiple)).x; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType isMultiple(vecType const & Value, T Multiple) + { + return (Value % Multiple) == vecType(0); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType isMultiple(vecType const & Value, vecType const & Multiple) + { + return (Value % Multiple) == vecType(0); + } + + ////////////////////// + // ceilMultiple + + template + GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple) + { + return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType ceilMultiple(vecType const & Source, vecType const & Multiple) + { + return detail::functor2::call(ceilMultiple, Source, Multiple); + } + + ////////////////////// + // floorMultiple + + template + GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple) + { + return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType floorMultiple(vecType const & Source, vecType const & Multiple) + { + return detail::functor2::call(floorMultiple, Source, Multiple); + } + + ////////////////////// + // roundMultiple + + template + GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple) + { + return detail::compute_roundMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType roundMultiple(vecType const & Source, vecType const & Multiple) + { + return detail::functor2::call(roundMultiple, Source, Multiple); + } +}//namespace glm diff --git a/glm/gtx/multiple.hpp b/glm/gtx/multiple.hpp index 93e83f3e..5b3196cb 100644 --- a/glm/gtx/multiple.hpp +++ b/glm/gtx/multiple.hpp @@ -39,11 +39,9 @@ #pragma once // Dependency: -#include "../glm.hpp" +#include "../gtc/round.hpp" -#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED)) -# pragma message("GLM: GLM_GTX_multiple extension included") -#endif +#pragma message("GLM: GLM_GTX_multiple extension is deprecated, use GLM_GTC_round instead.") namespace glm { @@ -58,7 +56,7 @@ namespace glm /// /// @see gtx_multiple template - GLM_FUNC_DECL genType higherMultiple( + GLM_DEPRECATED GLM_FUNC_DECL genType higherMultiple( genType Source, genType Multiple); @@ -70,7 +68,7 @@ namespace glm /// /// @see gtx_multiple template class vecType> - GLM_FUNC_DECL vecType higherMultiple( + GLM_DEPRECATED GLM_FUNC_DECL vecType higherMultiple( vecType const & Source, vecType const & Multiple); @@ -82,7 +80,7 @@ namespace glm /// /// @see gtx_multiple template - GLM_FUNC_DECL genType lowerMultiple( + GLM_DEPRECATED GLM_FUNC_DECL genType lowerMultiple( genType Source, genType Multiple); @@ -94,7 +92,7 @@ namespace glm /// /// @see gtx_multiple template class vecType> - GLM_FUNC_DECL vecType lowerMultiple( + GLM_DEPRECATED GLM_FUNC_DECL vecType lowerMultiple( vecType const & Source, vecType const & Multiple); diff --git a/glm/gtx/multiple.inl b/glm/gtx/multiple.inl index 864936af..fe175d46 100644 --- a/glm/gtx/multiple.inl +++ b/glm/gtx/multiple.inl @@ -10,114 +10,15 @@ // - GLM core /////////////////////////////////////////////////////////////////////////////////////////////////// -namespace glm{ -namespace detail +namespace glm { - template - struct compute_higherMultiple{}; - - template <> - struct compute_higherMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - if(Source > genType(0)) - { - genType Tmp = Source - genType(1); - return Tmp + (Multiple - std::fmod(Tmp, Multiple)); - } - else - return Source + std::fmod(-Source, Multiple); - } - }; - - template <> - struct compute_higherMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - genType Tmp = Source - genType(1); - return Tmp + (Multiple - (Tmp % Multiple)); - } - }; - - template <> - struct compute_higherMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - if(Source > genType(0)) - { - genType Tmp = Source - genType(1); - return Tmp + (Multiple - (Tmp % Multiple)); - } - else - return Source + (-Source % Multiple); - } - }; - - template - struct compute_lowerMultiple{}; - - template <> - struct compute_lowerMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - if(Source >= genType(0)) - return Source - std::fmod(Source, Multiple); - else - { - genType Tmp = Source + genType(1); - return Tmp - std::fmod(Tmp, Multiple) - Multiple; - } - } - }; - - template <> - struct compute_lowerMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - if(Source >= genType(0)) - return Source - Source % Multiple; - else - { - genType Tmp = Source + genType(1); - return Tmp - Tmp % Multiple - Multiple; - } - } - }; - - template <> - struct compute_lowerMultiple - { - template - GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple) - { - if(Source >= genType(0)) - return Source - Source % Multiple; - else - { - genType Tmp = Source + genType(1); - return Tmp - Tmp % Multiple - Multiple; - } - } - }; -}//namespace detail - ////////////////////// // higherMultiple template GLM_FUNC_QUALIFIER genType higherMultiple(genType Source, genType Multiple) { - return detail::compute_higherMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); + return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template class vecType> @@ -132,7 +33,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType lowerMultiple(genType Source, genType Multiple) { - return detail::compute_lowerMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); + return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } template class vecType> diff --git a/readme.txt b/readme.txt index dd82ff44..99ad989d 100644 --- a/readme.txt +++ b/readme.txt @@ -56,6 +56,7 @@ Features: - Added 'uninitialize' to explicitly not initialize a GLM type - Added GTC_bitfield extension, promoted GTX_bit - Added GTC_integer extension, promoted GTX_bit +- Added GTC_round extension, promoted GTX_bit Deprecation: - Removed degrees for function parameters diff --git a/test/gtc/CMakeLists.txt b/test/gtc/CMakeLists.txt index 3483c101..224b8eb5 100644 --- a/test/gtc/CMakeLists.txt +++ b/test/gtc/CMakeLists.txt @@ -10,6 +10,7 @@ glmCreateTestGTC(gtc_noise) glmCreateTestGTC(gtc_packing) glmCreateTestGTC(gtc_quaternion) glmCreateTestGTC(gtc_random) +glmCreateTestGTC(gtc_round) glmCreateTestGTC(gtc_reciprocal) glmCreateTestGTC(gtc_type_precision) glmCreateTestGTC(gtc_type_ptr) diff --git a/test/gtc/gtc_round.cpp b/test/gtc/gtc_round.cpp new file mode 100644 index 00000000..d5af5ed6 --- /dev/null +++ b/test/gtc/gtc_round.cpp @@ -0,0 +1,39 @@ +/////////////////////////////////////////////////////////////////////////////////// +/// 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. +/// +/// @file test/gtc/gtc_round.cpp +/// @date 2014-11-03 / 2014-11-03 +/// @author Christophe Riccio +/// +/// @see core (dependence) +/// @see gtc_round (dependence) +/////////////////////////////////////////////////////////////////////////////////// + +#include + +int main() +{ + int Error = 0; + + + return Error; +}