Merge branch 'GTC_integer'

glm/detail/func_common.inl

@@ -156,16 +156,20 @@ namespace detail
 	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
 	{
 		GLM_STATIC_ASSERT(
-			std::numeric_limits<genFIType>::is_iec559 ||
-			(std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), "'sign' only accept signed inputs");
+			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
+			"'sign' only accept signed inputs");
 		
-		return genFIType(genFIType(0) < x) - (x < genFIType(0));
+		return static_cast<genFIType>(static_cast<genFIType>(0) < x) - static_cast<genFIType>(x < static_cast<genFIType>(0));
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(sign, x);
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
 	}
 
 	// floor

glm/gtc/integer.hpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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_integer
+/// @file glm/gtc/integer.hpp
+/// @date 2014-11-17 / 2014-11-17
+/// @author Christophe Riccio
+///
+/// @see core (dependence)
+/// @see gtc_integer (dependence)
+///
+/// @defgroup gtc_integer GLM_GTC_integer
+/// @ingroup gtc
+/// 
+/// @brief Allow to perform bit operations on integer values
+/// 
+/// <glm/gtc/integer.hpp> need to be included to use these functionalities.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/precision.hpp"
+#include "../detail/func_integer.hpp"
+#include "../detail/func_exponential.hpp"
+#include <limits>
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#	pragma message("GLM: GLM_GTC_integer extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtc_integer
+	/// @{
+
+	/// Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
+	/// From GLM_GTC_integer extension.
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType log2(genIUType x);
+
+	/// @}
+} //namespace glm
+
+#include "integer.inl"

glm/gtc/integer.inl

@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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_integer
+/// @file glm/gtc/integer.inl
+/// @date 2014-11-17 / 2014-11-17
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) 
+	{
+		return 31u - findMSB(x);
+	}
+
+	template <>
+	struct compute_log2<false>
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
+		{
+			return Value <= static_cast<T>(1) ? T(0) : T(32) - nlz(Value - T(1));
+		}
+	};
+}//namespace detail
+}//namespace glm

glm/gtx/integer.hpp

@@ -39,6 +39,7 @@
 
 // Dependency:
 #include "../glm.hpp"
+#include "../gtc/integer.hpp"
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
 #	pragma message("GLM: GLM_GTX_integer extension included")
@@ -57,11 +58,6 @@ namespace glm
 	//! From GLM_GTX_integer extension.
 	GLM_FUNC_DECL int sqrt(int x);
 
-	//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
-	//! From GLM_GTX_integer extension.
-	template <typename genIUType>
-	GLM_FUNC_DECL genIUType log2(genIUType x);
-
 	//! Returns the floor log2 of x.
 	//! From GLM_GTX_integer extension.
 	GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);

glm/gtx/integer.inl

@@ -53,21 +53,7 @@ namespace detail
 		x += (x >> 16);
 		return(x & 0x0000003f);
 	}
-
-	template <>
-	struct compute_log2<false>
-	{
-		template <typename T>
-		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
-		{
-#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
-			return Value <= static_cast<T>(1) ? T(0) : T(32) - nlz(Value - T(1));
-#else
-			return T(32) - nlz(Value - T(1));
-#endif
-		}
-	};
-}//namespace _detail
+}//namespace detail
 
 	// Henry Gordon Dietz: http://aggregate.org/MAGIC/
 /*

readme.txt

@@ -55,7 +55,7 @@ Features:
 - Added GLM_FORCE_NO_CTOR_INIT
 - 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_integer extension, promoted GTX_bit and GTX_integer
 - Added GTC_round extension, promoted GTX_bit
 - Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269
 

test/core/core_func_common.cpp

@@ -855,6 +855,12 @@ namespace sign
 
 		int Error = 0;
 
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = glm::sign(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
 		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
 		{
 			glm::int32 Result = sign_cmp(Data[i].Value);
@@ -888,11 +894,36 @@ namespace sign
 		return Error;
 	}
 
+	int test_i32vec4()
+	{
+		type<glm::i32vec4> const Data[] =
+		{
+			{glm::i32vec4( 1), glm::i32vec4( 1)},
+			{glm::i32vec4( 0), glm::i32vec4( 0)},
+			{glm::i32vec4( 2), glm::i32vec4( 1)},
+			{glm::i32vec4( 3), glm::i32vec4( 1)},
+			{glm::i32vec4(-1), glm::i32vec4(-1)},
+			{glm::i32vec4(-2), glm::i32vec4(-1)},
+			{glm::i32vec4(-3), glm::i32vec4(-1)}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::i32vec4>); ++i)
+		{
+			glm::i32vec4 Result = glm::sign(Data[i].Value);
+			Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
 	int test()
 	{
 		int Error = 0;
 
 		Error += test_int32();
+		Error += test_i32vec4();
 
 		return Error;
 	}

test/gtc/CMakeLists.txt

@@ -1,6 +1,7 @@
 glmCreateTestGTC(gtc_bitfield)
 glmCreateTestGTC(gtc_constants)
 glmCreateTestGTC(gtc_epsilon)
+glmCreateTestGTC(gtc_integer)
 glmCreateTestGTC(gtc_matrix_access)
 glmCreateTestGTC(gtc_matrix_integer)
 glmCreateTestGTC(gtc_matrix_inverse)

test/gtc/gtc_integer.cpp

@@ -0,0 +1,68 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2014-11-17
+// Updated : 2014-11-17
+// Licence : This source is under MIT licence
+// File    : test/gtc/integer.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/integer.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <ctime>
+#include <cstdio>
+#include <vector>
+
+namespace log2_
+{
+	int test()
+	{
+		int Error = 0;
+
+		int A0(glm::log2(10.f));
+		glm::ivec1 B0(glm::log2(glm::vec1(10.f)));
+		glm::ivec2 C0(glm::log2(glm::vec2(10.f)));
+		glm::ivec3 D0(glm::log2(glm::vec3(10.f)));
+		glm::ivec4 E0(glm::log2(glm::vec4(10.f)));
+
+		int A1 = glm::log2(int(10.f));
+		glm::ivec1 B1 = glm::log2(glm::ivec1(10.f));
+		glm::ivec2 C1 = glm::log2(glm::ivec2(10.f));
+		glm::ivec3 D1 = glm::log2(glm::ivec3(10.f));
+		glm::ivec4 E1 = glm::log2(glm::ivec4(10.f));
+
+		Error += A0 == A1 ? 0 : 1;
+		Error += glm::all(glm::equal(B0, B1)) ? 0 : 1;
+		Error += glm::all(glm::equal(C0, C1)) ? 0 : 1;
+		Error += glm::all(glm::equal(D0, D1)) ? 0 : 1;
+		Error += glm::all(glm::equal(E0, E1)) ? 0 : 1;
+
+		return Error;
+	}
+
+	int perf()
+	{
+		int Error = 0;
+
+		return Error;
+	}
+}//namespace log2_
+
+
+int main()
+{
+	int Error(0);
+
+	Error += ::log2_::test();
+
+#	ifdef GLM_TEST_ENABLE_PERF
+		Error += ::log2_::perf();
+#	endif
+
+	return Error;
+}