Added test files

test/img/multiple.cpp

@@ -0,0 +1,127 @@
+#include "../precompiled.hpp"
+#include <glm/glm.hpp>
+#include <glm/img/multiple.hpp>
+
+namespace glm{
+namespace test
+{
+	bool main_img_multiple()
+	{
+		bool Success = true;
+
+		{
+			glm::detail::thalf Source(24.f);
+			glm::detail::thalf Multiple(16.f);
+
+			glm::detail::thalf Value = glm::higherMultiple(Source, Multiple);
+			float ExpectedResult(32.f);
+			float ValueFloat = Value;
+
+			Success = Success && ExpectedResult == ValueFloat;
+			assert(Success);
+		}
+
+		{
+			float Source(24.f);
+			float Multiple(16.f);
+
+			float Value = glm::higherMultiple(Source, Multiple);
+			float ExpectedResult(32.f);
+
+			Success = Success && ExpectedResult == Value;
+			assert(Success);
+		}
+
+		{
+			glm::ivec4 Source(16, 24, 47, 65);
+			glm::ivec4 Multiple(16);
+
+			glm::ivec4 Value = glm::higherMultiple(Source, Multiple);
+			glm::ivec4 ExpectedResult(16, 32, 48, 80);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec2 Source(16, 24);
+			glm::vec2 Multiple(16);
+
+			glm::vec2 Value = glm::higherMultiple(Source, Multiple);
+			glm::vec2 ExpectedResult(16, 32);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec3 Source(16, 24, 47);
+			glm::vec3 Multiple(16);
+
+			glm::vec3 Value = glm::higherMultiple(Source, Multiple);
+			glm::vec3 ExpectedResult(16, 32, 48);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec4 Source(16, 24, 47, 65);
+			glm::vec4 Multiple(16);
+
+			glm::vec4 Value = glm::higherMultiple(Source, Multiple);
+			glm::vec4 ExpectedResult(16, 32, 48, 80);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::ivec4 Source(16, 24, 47, 65);
+			glm::ivec4 Multiple(16);
+
+			glm::ivec4 Value = glm::lowerMultiple(Source, Multiple);
+			glm::ivec4 ExpectedResult(16, 16, 32, 64);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec2 Source(16, 24);
+			glm::vec2 Multiple(16);
+
+			glm::vec2 Value = glm::lowerMultiple(Source, Multiple);
+			glm::vec2 ExpectedResult(16, 16);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec3 Source(16, 24, 47);
+			glm::vec3 Multiple(16);
+
+			glm::vec3 Value = glm::lowerMultiple(Source, Multiple);
+			glm::vec3 ExpectedResult(16, 16, 32);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		{
+			glm::vec4 Source(16, 24, 47, 65);
+			glm::vec4 Multiple(16);
+
+			glm::vec4 Value = glm::lowerMultiple(Source, Multiple);
+			glm::vec4 ExpectedResult(16, 16, 32, 64);
+
+			Success = Success && glm::all(glm::equal(ExpectedResult, Value));
+			assert(Success);
+		}
+
+		return Success;
+	}
+
+}//namespace test
+}//namespace glm

test/img/wrap.cpp

@@ -0,0 +1,141 @@
+//#include "../precompiled.hpp"
+#include "../../glm/glm.hpp"
+#include "../../glm/gtc/half_float.hpp"
+#include "../../glm/gtc/double_float.hpp"
+#include "../../glm/img/wrap.hpp"
+
+namespace glm{
+namespace test
+{
+	static float const epsilon = 0.001f;
+
+	bool main_img_wrap()
+	{
+		bool Success = true;
+
+		// mirrorRepeat
+		{
+			float A = mirrorRepeat(0.0f); // 0.0f
+			Success = Success && (A - 0.0f) < epsilon;
+			assert(Success);
+
+			float B = mirrorRepeat(0.2f); // 0.2f
+			Success = Success && (B - 0.2f) < epsilon;
+			assert(Success);
+
+			float C = mirrorRepeat(0.5f); // 0.5f
+			Success = Success && (C - 0.5f) < epsilon;
+			assert(Success);
+
+			float D = mirrorRepeat(1.0f); // 1.0f
+			Success = Success && (D - 1.0f) < epsilon;
+			assert(Success);
+
+			float E = mirrorRepeat(1.2f); // 0.8f
+			Success = Success && (E - 0.8f) < epsilon;
+			assert(Success);
+
+			float F = mirrorRepeat(1.5f); // 0.5f
+			Success = Success && (F - 0.5f) < epsilon;
+			assert(Success);
+
+			float G = mirrorRepeat(1.6f); // 0.4f
+			Success = Success && (G - 0.4f) < epsilon;
+			assert(Success);
+
+			float H = mirrorRepeat(2.0f); // 0.0f
+			Success = Success && (H - 0.0f) < epsilon;
+			assert(Success);
+
+			float I = mirrorRepeat(2.1f); // 0.1f
+			Success = Success && (I - 0.1f) < epsilon;
+			assert(Success);
+
+			float J = mirrorRepeat(3.0f); // 1.0f
+			Success = Success && (J - 1.0f) < epsilon;
+			assert(Success);
+
+			float K = mirrorRepeat(3.9f); // 0.1f
+			Success = Success && (K - 0.1f) < epsilon;
+			assert(Success);
+
+			float L = mirrorRepeat(4.2f); // 0.2f
+			Success = Success && (L - 0.2f) < epsilon;
+			assert(Success);
+
+			float M = mirrorRepeat(3.9f); // 0.1f
+			Success = Success && (M - 0.1f) < epsilon;
+			assert(Success);
+
+			float N = mirrorRepeat(4.2f); // 0.2f
+			Success = Success && (N - 0.2f) < epsilon;
+			assert(Success);
+
+			float O = mirrorRepeat(5.2f); // 0.8f
+			Success = Success && (O - 0.8f) < epsilon;
+			assert(Success);
+
+			float P = mirrorRepeat(5.8f); // 0.2f
+			Success = Success && (P - 0.2f) < epsilon;
+			assert(Success);
+
+			float Q = mirrorRepeat(6.2f); // 0.2f
+			Success = Success && (Q - 0.2f) < epsilon;
+			assert(Success);
+
+			float R = mirrorRepeat(6.8f); // 0.8f
+			Success = Success && (R - 0.8f) < epsilon;
+			assert(Success);
+
+			float S = mirrorRepeat(7.0f); // 1.0f
+			Success = Success && (S - 1.0f) < epsilon;
+			assert(Success);
+		}
+
+		{
+			glm::vec2 A = mirrorRepeat(glm::vec2(0.0f)); // 0.0f
+			Success = Success && glm::all(glm::lessThan((A - 0.0f), glm::vec2(epsilon)));
+			assert(Success);
+
+			glm::vec3 B = mirrorRepeat(glm::vec3(0.2f)); // 0.2f
+			Success = Success && glm::all(glm::lessThan((B - 0.2f), glm::vec3(epsilon)));
+			assert(Success);
+
+			glm::vec4 C = mirrorRepeat(glm::vec4(1.2f)); // 0.8f
+			Success = Success && glm::all(glm::lessThan((C - 0.8f), glm::vec4(epsilon)));
+			assert(Success);
+		}
+
+		{
+			glm::hvec2 A = mirrorRepeat(glm::hvec2(0.0f)); // 0.0f
+			Success = Success && glm::all(glm::lessThan((A - glm::half(0.0f)), glm::hvec2(epsilon)));
+			assert(Success);
+
+			glm::hvec3 B = mirrorRepeat(glm::hvec3(0.2f)); // 0.2f
+			Success = Success && glm::all(glm::lessThan((B - glm::half(0.2f)), glm::hvec3(epsilon)));
+			assert(Success);
+
+			glm::hvec4 C = mirrorRepeat(glm::hvec4(1.2f)); // 0.8f
+			Success = Success && glm::all(glm::lessThan((C - glm::half(0.8f)), glm::hvec4(epsilon)));
+			assert(Success);
+		}
+
+		{
+			glm::dvec2 A = mirrorRepeat(glm::dvec2(0.0f)); // 0.0f
+			Success = Success && glm::all(glm::lessThan((A - double(0.0f)), glm::dvec2(epsilon)));
+			assert(Success);
+
+			glm::dvec3 B = mirrorRepeat(glm::dvec3(0.2f)); // 0.2f
+			Success = Success && glm::all(glm::lessThan((B - double(0.2f)), glm::dvec3(epsilon)));
+			assert(Success);
+
+			glm::dvec4 C = mirrorRepeat(glm::dvec4(1.2f)); // 0.8f
+			Success = Success && glm::all(glm::lessThan((C - double(0.8f)), glm::dvec4(epsilon)));
+			assert(Success);
+		}
+
+		return Success;
+	}
+
+}//namespace test
+}//namespace glm