Added GTX_wrap

glm/CMakeLists.txt

@@ -33,7 +33,7 @@ source_group("GTX Files" FILES ${GTX_HEADER})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 if(GLM_TEST_ENABLE)
-	add_executable(${NAME} ${ROOT_TEXT} ${ROOT_NAT}
+	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}

glm/gtx/wrap.inl

@@ -33,67 +33,46 @@
 namespace glm
 {
 	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType clamp
+	GLM_FUNC_QUALIFIER genType clamp(genType const & Texcoord)
-	(
-		genType const & Texcoord
-	)
 	{
 		return glm::clamp(Texcoord, genType(0), genType(1));
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec2<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec2<T, P> clamp(tvec2<T, P> const & Texcoord)
-	(
-		tvec2<T, P> const & Texcoord
-	)
 	{
 		tvec2<T, P> Result;
 		for(typename tvec2<T, P>::size_type i = 0; i < tvec2<T, P>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
+			Result[i] = clamp_to_edge(Texcoord[i]);
 		return Result;
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec3<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec3<T, P> clamp(tvec3<T, P> const & Texcoord)
-	(
-		tvec3<T, P> const & Texcoord
-	)
 	{
 		tvec3<T, P> Result;
 		for(typename tvec3<T, P>::size_type i = 0; i < tvec3<T, P>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
+			Result[i] = clamp_to_edge(Texcoord[i]);
 		return Result;
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec4<T, P> clamp(tvec4<T, P> const & Texcoord)
-	(
-		tvec4<T, P> const & Texcoord
-	)
 	{
 		tvec4<T, P> Result;
 		for(typename tvec4<T, P>::size_type i = 0; i < tvec4<T, P>::value_size(); ++i)
-			Result[i] = clamp(Texcoord[i]);
+			Result[i] = clamp_to_edge(Texcoord[i]);
 		return Result;
 	}
 
-	////////////////////////
+	template <typename genType>
-	// repeat
+	GLM_FUNC_QUALIFIER genType repeat(genType const & Texcoord)
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType repeat
-	(
-		genType const & Texcoord
-	)
 	{
 		return glm::fract(Texcoord);
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> repeat
+	GLM_FUNC_QUALIFIER tvec2<T, P> repeat(tvec2<T, P> const & Texcoord)
-	(
-		tvec2<T, P> const & Texcoord
-	)
 	{
 		tvec2<T, P> Result;
 		for(typename tvec2<T, P>::size_type i = 0; i < tvec2<T, P>::value_size(); ++i)
@@ -101,11 +80,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> repeat
+	GLM_FUNC_QUALIFIER tvec3<T, P> repeat(tvec3<T, P> const & Texcoord)
-	(
-		tvec3<T, P> const & Texcoord
-	)
 	{
 		tvec3<T, P> Result;
 		for(typename tvec3<T, P>::size_type i = 0; i < tvec3<T, P>::value_size(); ++i)
@@ -113,11 +89,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> repeat
+	GLM_FUNC_QUALIFIER tvec4<T, P> repeat(tvec4<T, P> const & Texcoord)
-	(
-		tvec4<T, P> const & Texcoord
-	)
 	{
 		tvec4<T, P> Result;
 		for(typename tvec4<T, P>::size_type i = 0; i < tvec4<T, P>::value_size(); ++i)
@@ -125,18 +98,13 @@ namespace glm
 		return Result;
 	}
 
-	////////////////////////
+	template <typename genType>
-	// mirrorRepeat
+	GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const & Texcoord)
-
-	template <typename genType, precision P> 
-	GLM_FUNC_QUALIFIER genType mirrorRepeat
-	(
-		genType const & Texcoord
-	)
 	{
-		genType const Clamp = genType(int(glm::floor(Texcoord)) % 2);
+		genType const Abs = glm::abs(Texcoord);
-		genType const Floor = glm::floor(Texcoord);
+		genType const Clamp = genType(int(glm::floor(Abs)) % 2);
-		genType const Rest = Texcoord - Floor;
+		genType const Floor = glm::floor(Abs);
+		genType const Rest = Abs - Floor;
 		genType const Mirror = Clamp + Rest;
 
 		genType Out;
@@ -147,11 +115,8 @@ namespace glm
 		return Out;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> mirrorRepeat
+	GLM_FUNC_QUALIFIER tvec2<T, P> mirrorRepeat(tvec2<T, P> const & Texcoord)
-	(
-		tvec2<T, P> const & Texcoord
-	)
 	{
 		tvec2<T, P> Result;
 		for(typename tvec2<T, P>::size_type i = 0; i < tvec2<T, P>::value_size(); ++i)
@@ -159,11 +124,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> mirrorRepeat
+	GLM_FUNC_QUALIFIER tvec3<T, P> mirrorRepeat(tvec3<T, P> const & Texcoord)
-	(
-		tvec3<T, P> const & Texcoord
-	)
 	{
 		tvec3<T, P> Result;
 		for(typename tvec3<T, P>::size_type i = 0; i < tvec3<T, P>::value_size(); ++i)
@@ -171,11 +133,8 @@ namespace glm
 		return Result;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> mirrorRepeat
+	GLM_FUNC_QUALIFIER tvec4<T, P> mirrorRepeat(tvec4<T, P> const & Texcoord)
-	(
-		tvec4<T, P> const & Texcoord
-	)
 	{
 		tvec4<T, P> Result;
 		for(typename tvec4<T, P>::size_type i = 0; i < tvec4<T, P>::value_size(); ++i)

readme.md

@@ -56,7 +56,8 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
 - Added 'fmod' overload to GTX_common with tests #308
 - Left handed perspective and lookAt functions #314
 - Added functions eulerAngleXYZ and extractEulerAngleXYZ #311
-- Added <glm/gtx/hash.hpp> to perform to perform std::hash on GLM types #320
+- Added <glm/gtx/hash.hpp> to perform std::hash on GLM types #320
+- Added <glm/gtx/wrap.hpp> for texcoord wrapping
 
 ##### Improvements:
 - Changed usage of __has_include to support Intel compiler #307

test/gtx/CMakeLists.txt

@@ -48,3 +48,4 @@ glmCreateTestGTC(gtx_string_cast)
 glmCreateTestGTC(gtx_type_aligned)
 glmCreateTestGTC(gtx_vector_angle)
 glmCreateTestGTC(gtx_vector_query)
+glmCreateTestGTC(gtx_wrap)

test/gtx/gtx_wrap.cpp

@@ -0,0 +1,134 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @file test/gtx/gtx_normal.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/wrap.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+namespace clamp
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::clamp(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::clamp(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::clamp(1.0f);
+		Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::clamp(-0.5f);
+		Error += glm::epsilonEqual(D, 0.0f, 0.00001f) ? 0 : 1;
+
+		float E = glm::clamp(1.5f);
+		Error += glm::epsilonEqual(E, 1.0f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace clamp
+
+namespace repeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::repeat(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::repeat(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::repeat(1.0f);
+		Error += glm::epsilonEqual(C, 0.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::repeat(-0.5f);
+		Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::repeat(1.5f);
+		Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::repeat(0.9f);
+		Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace repeat
+
+namespace mirrorRepeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::mirrorRepeat(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::mirrorRepeat(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::mirrorRepeat(1.0f);
+		Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::mirrorRepeat(-0.5f);
+		Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::mirrorRepeat(1.5f);
+		Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::mirrorRepeat(0.9f);
+		Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		float G = glm::mirrorRepeat(3.0f);
+		Error += glm::epsilonEqual(G, 1.0f, 0.00001f) ? 0 : 1;
+
+		float H = glm::mirrorRepeat(-3.0f);
+		Error += glm::epsilonEqual(H, 1.0f, 0.00001f) ? 0 : 1;
+
+		float I = glm::mirrorRepeat(-1.0f);
+		Error += glm::epsilonEqual(I, 1.0f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace mirrorRepeat
+
+int main()
+{
+	int Error(0);
+
+	Error += clamp::test();
+	Error += repeat::test();
+	Error += mirrorRepeat::test();
+
+	return Error;
+}