Changeset: 35 Fix missing sources in git submodules after migration to PlasticSCM

1 files changed, 205 insertions, 0 deletions

diff --git a/3rdparty/glm/source/test/ext/ext_vector_relational.cpp b/3rdparty/glm/source/test/ext/ext_vector_relational.cpp
new file mode 100644
index 0000000..f6cd307
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_relational.cpp
@@ -0,0 +1,205 @@
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float1_precision.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float2_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float4_precision.hpp>
+#include <glm/ext/vector_double1.hpp>
+#include <glm/ext/vector_double1_precision.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double2_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/vector_double4_precision.hpp>
+#include <glm/ext/vector_ulp.hpp>
+
+template <typename vecType>
+static int test_equal()
+{
+	typedef typename vecType::value_type valType;
+
+	valType const A = static_cast<valType>(1.01f);
+	valType const B = static_cast<valType>(1.02f);
+	valType const Epsilon1 = static_cast<valType>(0.1f);
+	valType const Epsilon2 = static_cast<valType>(0.001f);
+
+	int Error = 0;
+
+	Error += glm::all(glm::equal(vecType(A), vecType(B), Epsilon1)) ? 0 : 1;
+	Error += glm::all(glm::equal(vecType(A), vecType(B), vecType(Epsilon1))) ? 0 : 1;
+
+	Error += !glm::any(glm::equal(vecType(A), vecType(B), Epsilon2)) ? 0 : 1;
+	Error += !glm::any(glm::equal(vecType(A), vecType(B), vecType(Epsilon2))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_notEqual()
+{
+	typedef typename vecType::value_type valType;
+
+	valType const A = static_cast<valType>(1.01f);
+	valType const B = static_cast<valType>(1.02f);
+	valType const Epsilon1 = static_cast<valType>(0.1f);
+	valType const Epsilon2 = static_cast<valType>(0.001f);
+
+	int Error = 0;
+
+	Error += glm::all(glm::notEqual(vecType(A), vecType(B), Epsilon2)) ? 0 : 1;
+	Error += glm::all(glm::notEqual(vecType(A), vecType(B), vecType(Epsilon2))) ? 0 : 1;
+
+	Error += !glm::any(glm::notEqual(vecType(A), vecType(B), Epsilon1)) ? 0 : 1;
+	Error += !glm::any(glm::notEqual(vecType(A), vecType(B), vecType(Epsilon1))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType, typename valType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(glm::all(glm::equal(genType(static_cast<valType>(1.01f)), genType(static_cast<valType>(1.02f)), static_cast<valType>(0.1f))), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+template <typename T>
+static int test_equal_ulps()
+{
+	typedef glm::vec<4, T, glm::defaultp> vec4;
+
+	T const One(1);
+	vec4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += glm::all(glm::equal(Ones, vec4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += !glm::all(glm::equal(Ones, vec4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += glm::all(glm::equal(Ones, vec4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += !glm::all(glm::equal(Ones, vec4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_notEqual_ulps()
+{
+	typedef glm::vec<4, T, glm::defaultp> vec4;
+
+	T const One(1);
+	vec4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, vec4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += glm::all(glm::notEqual(Ones, vec4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, vec4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += glm::all(glm::notEqual(Ones, vec4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_equal_ulps<float>();
+	Error += test_equal_ulps<double>();
+	Error += test_notEqual_ulps<float>();
+	Error += test_notEqual_ulps<double>();
+
+	Error += test_equal<glm::vec1>();
+	Error += test_equal<glm::lowp_vec1>();
+	Error += test_equal<glm::mediump_vec1>();
+	Error += test_equal<glm::highp_vec1>();
+	Error += test_equal<glm::vec2>();
+	Error += test_equal<glm::lowp_vec2>();
+	Error += test_equal<glm::mediump_vec2>();
+	Error += test_equal<glm::highp_vec2>();
+	Error += test_equal<glm::vec3>();
+	Error += test_equal<glm::lowp_vec3>();
+	Error += test_equal<glm::mediump_vec3>();
+	Error += test_equal<glm::highp_vec3>();
+	Error += test_equal<glm::vec4>();
+	Error += test_equal<glm::lowp_vec4>();
+	Error += test_equal<glm::mediump_vec4>();
+	Error += test_equal<glm::highp_vec4>();
+
+	Error += test_equal<glm::dvec1>();
+	Error += test_equal<glm::lowp_dvec1>();
+	Error += test_equal<glm::mediump_dvec1>();
+	Error += test_equal<glm::highp_dvec1>();
+	Error += test_equal<glm::dvec2>();
+	Error += test_equal<glm::lowp_dvec2>();
+	Error += test_equal<glm::mediump_dvec2>();
+	Error += test_equal<glm::highp_dvec2>();
+	Error += test_equal<glm::dvec3>();
+	Error += test_equal<glm::lowp_dvec3>();
+	Error += test_equal<glm::mediump_dvec3>();
+	Error += test_equal<glm::highp_dvec3>();
+	Error += test_equal<glm::dvec4>();
+	Error += test_equal<glm::lowp_dvec4>();
+	Error += test_equal<glm::mediump_dvec4>();
+	Error += test_equal<glm::highp_dvec4>();
+
+	Error += test_notEqual<glm::vec1>();
+	Error += test_notEqual<glm::lowp_vec1>();
+	Error += test_notEqual<glm::mediump_vec1>();
+	Error += test_notEqual<glm::highp_vec1>();
+	Error += test_notEqual<glm::vec2>();
+	Error += test_notEqual<glm::lowp_vec2>();
+	Error += test_notEqual<glm::mediump_vec2>();
+	Error += test_notEqual<glm::highp_vec2>();
+	Error += test_notEqual<glm::vec3>();
+	Error += test_notEqual<glm::lowp_vec3>();
+	Error += test_notEqual<glm::mediump_vec3>();
+	Error += test_notEqual<glm::highp_vec3>();
+	Error += test_notEqual<glm::vec4>();
+	Error += test_notEqual<glm::lowp_vec4>();
+	Error += test_notEqual<glm::mediump_vec4>();
+	Error += test_notEqual<glm::highp_vec4>();
+
+	Error += test_notEqual<glm::dvec1>();
+	Error += test_notEqual<glm::lowp_dvec1>();
+	Error += test_notEqual<glm::mediump_dvec1>();
+	Error += test_notEqual<glm::highp_dvec1>();
+	Error += test_notEqual<glm::dvec2>();
+	Error += test_notEqual<glm::lowp_dvec2>();
+	Error += test_notEqual<glm::mediump_dvec2>();
+	Error += test_notEqual<glm::highp_dvec2>();
+	Error += test_notEqual<glm::dvec3>();
+	Error += test_notEqual<glm::lowp_dvec3>();
+	Error += test_notEqual<glm::mediump_dvec3>();
+	Error += test_notEqual<glm::highp_dvec3>();
+	Error += test_notEqual<glm::dvec4>();
+	Error += test_notEqual<glm::lowp_dvec4>();
+	Error += test_notEqual<glm::mediump_dvec4>();
+	Error += test_notEqual<glm::highp_dvec4>();
+
+	Error += test_constexpr<glm::vec1, float>();
+	Error += test_constexpr<glm::vec2, float>();
+	Error += test_constexpr<glm::vec3, float>();
+	Error += test_constexpr<glm::vec4, float>();
+
+	return Error;
+}