BlackMATov/vmath.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/vmath.hpp.git synced 2025-12-15 12:39:47 +07:00
Code Issues Packages Projects Releases Wiki Activity

hlsl typedefs style instead glsl

Browse Source
This commit is contained in:
BlackMATov
2020-11-26 00:40:47 +07:00
parent 163afb6c98
commit 8dc6878f5c
7 changed files with 446 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
headers/vmath.hpp/vmath_fwd.hpp
View File

@@ -22,29 +22,29 @@ namespace vmath_hpp
template < typename T, std::size_t Size >
class vec;
using vec2i = vec<int, 2>;
using vec3i = vec<int, 3>;
using vec4i = vec<int, 4>;
using bool2 = vec<bool, 2>;
using bool3 = vec<bool, 3>;
using bool4 = vec<bool, 4>;
using vec2b = vec<bool, 2>;
using vec3b = vec<bool, 3>;
using vec4b = vec<bool, 4>;
using int2 = vec<int, 2>;
using int3 = vec<int, 3>;
using int4 = vec<int, 4>;
using vec2f = vec<float, 2>;
using vec3f = vec<float, 3>;
using vec4f = vec<float, 4>;
using uint2 = vec<unsigned, 2>;
using uint3 = vec<unsigned, 3>;
using uint4 = vec<unsigned, 4>;
using vec2d = vec<double, 2>;
using vec3d = vec<double, 3>;
using vec4d = vec<double, 4>;
using float2 = vec<float, 2>;
using float3 = vec<float, 3>;
using float4 = vec<float, 4>;
using vec2u = vec<unsigned, 2>;
using vec3u = vec<unsigned, 3>;
using vec4u = vec<unsigned, 4>;
using double2 = vec<double, 2>;
using double3 = vec<double, 3>;
using double4 = vec<double, 4>;
using vec2z = vec<std::size_t, 2>;
using vec3z = vec<std::size_t, 3>;
using vec4z = vec<std::size_t, 4>;
using size2 = vec<std::size_t, 2>;
using size3 = vec<std::size_t, 3>;
using size4 = vec<std::size_t, 4>;
}
namespace vmath_hpp
@@ -52,27 +52,27 @@ namespace vmath_hpp
template < typename T, std::size_t Size >
class mat;
using mat2i = mat<int, 2>;
using mat3i = mat<int, 3>;
using mat4i = mat<int, 4>;
using bool2x2 = mat<bool, 2>;
using bool3x3 = mat<bool, 3>;
using bool4x4 = mat<bool, 4>;
using mat2b = mat<bool, 2>;
using mat3b = mat<bool, 3>;
using mat4b = mat<bool, 4>;
using int2x2 = mat<int, 2>;
using int3x3 = mat<int, 3>;
using int4x4 = mat<int, 4>;
using mat2f = mat<float, 2>;
using mat3f = mat<float, 3>;
using mat4f = mat<float, 4>;
using uint2x2 = mat<unsigned, 2>;
using uint3x3 = mat<unsigned, 3>;
using uint4x4 = mat<unsigned, 4>;
using mat2d = mat<double, 2>;
using mat3d = mat<double, 3>;
using mat4d = mat<double, 4>;
using float2x2 = mat<float, 2>;
using float3x3 = mat<float, 3>;
using float4x4 = mat<float, 4>;
using mat2u = mat<unsigned, 2>;
using mat3u = mat<unsigned, 3>;
using mat4u = mat<unsigned, 4>;
using double2x2 = mat<double, 2>;
using double3x3 = mat<double, 3>;
using double4x4 = mat<double, 4>;
using mat2z = mat<std::size_t, 2>;
using mat3z = mat<std::size_t, 3>;
using mat4z = mat<std::size_t, 4>;
using size2x2 = mat<std::size_t, 2>;
using size3x3 = mat<std::size_t, 3>;
using size4x4 = mat<std::size_t, 4>;
}

68
untests/vmath_mat_ext_tests.cpp
View File

@@ -19,70 +19,70 @@ namespace
TEST_CASE("vmath/mat_ext") {
SECTION("units") {
STATIC_REQUIRE(zero2x2<int>() == mat2i(0,0,0,0));
STATIC_REQUIRE(zero3x3<int>() == mat3i(0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(zero4x4<int>() == mat4i(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(zero2x2<int>() == int2x2(0,0,0,0));
STATIC_REQUIRE(zero3x3<int>() == int3x3(0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(zero4x4<int>() == int4x4(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0));
STATIC_REQUIRE(unit2x2<int>() == mat2i(1,1,1,1));
STATIC_REQUIRE(unit3x3<int>() == mat3i(1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(unit4x4<int>() == mat4i(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(unit2x2<int>() == int2x2(1,1,1,1));
STATIC_REQUIRE(unit3x3<int>() == int3x3(1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(unit4x4<int>() == int4x4(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
STATIC_REQUIRE(identity2x2<int>() == mat2i());
STATIC_REQUIRE(identity3x3<int>() == mat3i());
STATIC_REQUIRE(identity4x4<int>() == mat4i());
STATIC_REQUIRE(identity2x2<int>() == int2x2());
STATIC_REQUIRE(identity3x3<int>() == int3x3());
STATIC_REQUIRE(identity4x4<int>() == int4x4());
}
SECTION("hash") {
REQUIRE(std::hash<mat2i>{}({1,2,3,4}) == std::hash<mat2i>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<mat2i>{}({1,2,3,4}) == std::hash<mat2i>{}({1,2,4,3}));
REQUIRE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<int2x2>{}({1,2,3,4}) == std::hash<int2x2>{}({1,2,4,3}));
}
SECTION("cast_to") {
constexpr auto m = cast_to<int>(mat2f{1.5f});
STATIC_REQUIRE(m == mat2i(1));
STATIC_REQUIRE(std::is_same_v<decltype(m)::row_type, vec2i>);
constexpr auto m = cast_to<int>(float2x2{1.5f});
STATIC_REQUIRE(m == int2x2(1));
STATIC_REQUIRE(std::is_same_v<decltype(m)::row_type, int2>);
}
SECTION("row") {
STATIC_REQUIRE(row(mat2i(1,2,3,4), 0) == vec2i(1,2));
STATIC_REQUIRE(row(mat2i(1,2,3,4), 1) == vec2i(3,4));
STATIC_REQUIRE(row(int2x2(1,2,3,4), 0) == int2(1,2));
STATIC_REQUIRE(row(int2x2(1,2,3,4), 1) == int2(3,4));
STATIC_REQUIRE(row(mat2i(), 0, {1,2}) == mat2i(1,2,0,1));
STATIC_REQUIRE(row(mat2i(), 1, {3,4}) == mat2i(1,0,3,4));
STATIC_REQUIRE(row(int2x2(), 0, {1,2}) == int2x2(1,2,0,1));
STATIC_REQUIRE(row(int2x2(), 1, {3,4}) == int2x2(1,0,3,4));
}
SECTION("column") {
STATIC_REQUIRE(column(mat2i(1,2,3,4), 0) == vec2i(1,3));
STATIC_REQUIRE(column(mat2i(1,2,3,4), 1) == vec2i(2,4));
STATIC_REQUIRE(column(int2x2(1,2,3,4), 0) == int2(1,3));
STATIC_REQUIRE(column(int2x2(1,2,3,4), 1) == int2(2,4));
STATIC_REQUIRE(column(mat2i(), 0, {2,3}) == mat2i(2,0,3,1));
STATIC_REQUIRE(column(mat2i(), 1, {3,4}) == mat2i(1,3,0,4));
STATIC_REQUIRE(column(int2x2(), 0, {2,3}) == int2x2(2,0,3,1));
STATIC_REQUIRE(column(int2x2(), 1, {3,4}) == int2x2(1,3,0,4));
}
SECTION("translate") {
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * translate(1.f,2.f,3.f) == approx4(3.f,5.f,7.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * translate(vec3f{1.f,2.f,3.f}) == approx4(3.f,5.f,7.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(1.f,2.f,3.f) == approx4(3.f,5.f,7.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(float3{1.f,2.f,3.f}) == approx4(3.f,5.f,7.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * translate(translate(1.f,2.f,3.f), 1.f,2.f,3.f) == approx4(4.f,7.f,10.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * translate(translate(1.f,2.f,3.f), vec3f{1.f,2.f,3.f}) == approx4(4.f,7.f,10.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(translate(1.f,2.f,3.f), 1.f,2.f,3.f) == approx4(4.f,7.f,10.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * translate(translate(1.f,2.f,3.f), float3{1.f,2.f,3.f}) == approx4(4.f,7.f,10.f,1.f));
}
SECTION("rotate") {
constexpr float pi = radians(180.f);
constexpr float pi_2 = radians(90.f);
REQUIRE(vec4f(2.f,3.f,4.f,1.f) * rotate(pi,0.f,0.f,1.f) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(vec4f(2.f,3.f,4.f,1.f) * rotate(pi,vec3f{0.f,0.f,1.f}) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(pi,0.f,0.f,1.f) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(pi,float3{0.f,0.f,1.f}) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(vec4f(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,0.f,0.f,1.f),pi_2,0.f,0.f,1.f) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(vec4f(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,0.f,0.f,1.f),pi_2,vec3f{0.f,0.f,1.f}) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,0.f,0.f,1.f),pi_2,0.f,0.f,1.f) == approx4(-2.f,-3.f,4.f,1.f));
REQUIRE(float4(2.f,3.f,4.f,1.f) * rotate(rotate(pi_2,0.f,0.f,1.f),pi_2,float3{0.f,0.f,1.f}) == approx4(-2.f,-3.f,4.f,1.f));
}
SECTION("scale") {
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * scale(2.f,3.f,4.f) == approx4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * scale(vec3f{2.f,3.f,4.f}) == approx4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(2.f,3.f,4.f) == approx4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(float3{2.f,3.f,4.f}) == approx4(4.f,9.f,16.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * scale(scale(2.f,2.f,2.f), 2.f,3.f,4.f) == approx4(8.f,18.f,32.f,1.f));
STATIC_REQUIRE(vec4f(2.f,3.f,4.f,1.f) * scale(scale(2.f,2.f,2.f), vec3f{2.f,3.f,4.f}) == approx4(8.f,18.f,32.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(scale(2.f,2.f,2.f), 2.f,3.f,4.f) == approx4(8.f,18.f,32.f,1.f));
STATIC_REQUIRE(float4(2.f,3.f,4.f,1.f) * scale(scale(2.f,2.f,2.f), float3{2.f,3.f,4.f}) == approx4(8.f,18.f,32.f,1.f));
}
}

112
untests/vmath_mat_fun_tests.cpp
View File

@@ -37,104 +37,104 @@ namespace
TEST_CASE("vmath/mat_fun") {
SECTION("Operators") {
STATIC_REQUIRE(-mat2i(1,2,3,4) == mat2i(-1,-2,-3,-4));
STATIC_REQUIRE(-int2x2(1,2,3,4) == int2x2(-1,-2,-3,-4));
STATIC_REQUIRE(mat2i(1,2,3,4) + 2 == mat2i(3,4,5,6));
STATIC_REQUIRE(mat2i(1,2,3,4) - 2 == mat2i(-1,0,1,2));
STATIC_REQUIRE(mat2i(1,2,3,4) * 2 == mat2i(2,4,6,8));
STATIC_REQUIRE(mat2i(1,2,3,4) / 2 == mat2i(0,1,1,2));
STATIC_REQUIRE(int2x2(1,2,3,4) + 2 == int2x2(3,4,5,6));
STATIC_REQUIRE(int2x2(1,2,3,4) - 2 == int2x2(-1,0,1,2));
STATIC_REQUIRE(int2x2(1,2,3,4) * 2 == int2x2(2,4,6,8));
STATIC_REQUIRE(int2x2(1,2,3,4) / 2 == int2x2(0,1,1,2));
STATIC_REQUIRE(4 + mat2i(1,2,3,4) == mat2i(5,6,7,8));
STATIC_REQUIRE(4 - mat2i(1,2,3,4) == mat2i(3,2,1,0));
STATIC_REQUIRE(4 * mat2i(1,2,3,4) == mat2i(4,8,12,16));
STATIC_REQUIRE(4 / mat2i(1,2,3,4) == mat2i(4,2,1,1));
STATIC_REQUIRE(4 + int2x2(1,2,3,4) == int2x2(5,6,7,8));
STATIC_REQUIRE(4 - int2x2(1,2,3,4) == int2x2(3,2,1,0));
STATIC_REQUIRE(4 * int2x2(1,2,3,4) == int2x2(4,8,12,16));
STATIC_REQUIRE(4 / int2x2(1,2,3,4) == int2x2(4,2,1,1));
STATIC_REQUIRE(mat2i(1,2,3,4) + mat2i(5,6,7,8) == mat2i(6,8,10,12));
STATIC_REQUIRE(mat2i(1,2,3,4) - mat2i(5,6,7,8) == mat2i(-4,-4,-4,-4));
STATIC_REQUIRE(mat2i(5,6,7,8) / mat2i(1,2,3,4) == mat2i(5,3,2,2));
STATIC_REQUIRE(int2x2(1,2,3,4) + int2x2(5,6,7,8) == int2x2(6,8,10,12));
STATIC_REQUIRE(int2x2(1,2,3,4) - int2x2(5,6,7,8) == int2x2(-4,-4,-4,-4));
STATIC_REQUIRE(int2x2(5,6,7,8) / int2x2(1,2,3,4) == int2x2(5,3,2,2));
STATIC_REQUIRE(mat2i() * mat2i() == mat2i());
STATIC_REQUIRE(mat3i() * mat3i() == mat3i());
STATIC_REQUIRE(int2x2() * int2x2() == int2x2());
STATIC_REQUIRE(int3x3() * int3x3() == int3x3());
STATIC_REQUIRE(vec2i(1,2) * mat2i() == vec2i(1,2));
STATIC_REQUIRE(vec3i(1,2,3) * mat3i() == vec3i(1,2,3));
STATIC_REQUIRE(vec4i(1,2,3,4) * mat4i() == vec4i(1,2,3,4));
STATIC_REQUIRE(int2(1,2) * int2x2() == int2(1,2));
STATIC_REQUIRE(int3(1,2,3) * int3x3() == int3(1,2,3));
STATIC_REQUIRE(int4(1,2,3,4) * int4x4() == int4(1,2,3,4));
{
mat2i v{1,2,3,4};
int2x2 v{1,2,3,4};
REQUIRE(&v == &(v += 3));
REQUIRE(v == mat2i{4,5,6,7});
REQUIRE(&v == &(v += mat2i{1,2,3,4}));
REQUIRE(v == mat2i{5,7,9,11});
REQUIRE(v == int2x2{4,5,6,7});
REQUIRE(&v == &(v += int2x2{1,2,3,4}));
REQUIRE(v == int2x2{5,7,9,11});
}
{
mat2i v{4,5,6,7};
int2x2 v{4,5,6,7};
REQUIRE(&v == &(v -= 3));
REQUIRE(v == mat2i{1,2,3,4});
REQUIRE(&v == &(v -= mat2i{2,4,6,8}));
REQUIRE(v == mat2i{-1,-2,-3,-4});
REQUIRE(v == int2x2{1,2,3,4});
REQUIRE(&v == &(v -= int2x2{2,4,6,8}));
REQUIRE(v == int2x2{-1,-2,-3,-4});
}
{
mat2i v{1,2,3,4};
int2x2 v{1,2,3,4};
REQUIRE(&v == &(v *= 3));
REQUIRE(v == mat2i{3,6,9,12});
REQUIRE(v == int2x2{3,6,9,12});
}
{
mat2i v{6,18,36,60};
int2x2 v{6,18,36,60};
REQUIRE(&v == &(v /= 2));
REQUIRE(v == mat2i{3,9,18,30});
REQUIRE(&v == &(v /= mat2i{3,4,3,10}));
REQUIRE(v == mat2i{1,2,6,3});
REQUIRE(v == int2x2{3,9,18,30});
REQUIRE(&v == &(v /= int2x2{3,4,3,10}));
REQUIRE(v == int2x2{1,2,6,3});
}
{
vec4f v{0.f, 0.f, 0.f, 1.f};
float4 v{0.f, 0.f, 0.f, 1.f};
REQUIRE(&v == &(v *= translate(1.f,2.f,3.f)));
REQUIRE(v == approx4(1.f,2.f,3.f,1.f));
}
{
vec3f v{1.f, 2.f, 3.f};
REQUIRE(&v == &(v *= mat3f(scale(2.f,3.f,4.f))));
float3 v{1.f, 2.f, 3.f};
REQUIRE(&v == &(v *= float3x3(scale(2.f,3.f,4.f))));
REQUIRE(v == approx3(2.f,6.f,12.f));
}
{
mat4f v = translate(1.f, 2.f, 3.f);
float4x4 v = translate(1.f, 2.f, 3.f);
REQUIRE(&v == &(v *= translate(1.f,2.f,3.f)));
REQUIRE(v == approx4x4(translate(2.f,4.f,6.f)));
}
{
mat3f v = mat3f(scale(1.f, 2.f, 3.f));
REQUIRE(&v == &(v *= mat3f(scale(2.f,3.f,4.f))));
REQUIRE(v == approx3x3(mat3f(scale(2.f,6.f,12.f))));
float3x3 v = float3x3(scale(1.f, 2.f, 3.f));
REQUIRE(&v == &(v *= float3x3(scale(2.f,3.f,4.f))));
REQUIRE(v == approx3x3(float3x3(scale(2.f,6.f,12.f))));
}
}
SECTION("Matrix Functions") {
{
STATIC_REQUIRE(transpose(mat2i(
STATIC_REQUIRE(transpose(int2x2(
1, 2,
3, 4
)) == mat2i(
)) == int2x2(
1, 3,
2, 4
));
STATIC_REQUIRE(transpose(mat3i(
STATIC_REQUIRE(transpose(int3x3(
1, 2, 3,
4, 5, 6,
7, 8, 9
)) == mat3i(
)) == int3x3(
1, 4, 7,
2, 5, 8,
3, 6, 9
));
STATIC_REQUIRE(transpose(mat4i(
STATIC_REQUIRE(transpose(int4x4(
1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12,
13, 14, 15, 16
)) == mat4i(
)) == int4x4(
1, 5, 9, 13,
2, 6, 10, 14,
3, 7, 11, 15,
@@ -142,9 +142,9 @@ TEST_CASE("vmath/mat_fun") {
));
}
{
constexpr mat2i m2{1,2,3,4};
constexpr mat3i m3{1,2,3,4,5,6,7,8,9};
constexpr mat4i m4{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
constexpr int2x2 m2{1,2,3,4};
constexpr int3x3 m3{1,2,3,4,5,6,7,8,9};
constexpr int4x4 m4{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
STATIC_REQUIRE(determinant(m2) == determinant(transpose(m2)));
STATIC_REQUIRE(determinant(m3) == determinant(transpose(m3)));
STATIC_REQUIRE(determinant(m4) == determinant(transpose(m4)));
@@ -158,19 +158,19 @@ TEST_CASE("vmath/mat_fun") {
STATIC_REQUIRE(determinant(transpose(generate_frank_matrix<int, 4>())) == 1);
}
{
STATIC_REQUIRE(inverse(mat2i()) == mat2i());
STATIC_REQUIRE(inverse(mat3i()) == mat3i());
STATIC_REQUIRE(inverse(mat4i()) == mat4i());
STATIC_REQUIRE(inverse(int2x2()) == int2x2());
STATIC_REQUIRE(inverse(int3x3()) == int3x3());
STATIC_REQUIRE(inverse(int4x4()) == int4x4());
STATIC_REQUIRE(inverse(mat2f(0.5)) == mat2f(2.f));
STATIC_REQUIRE(inverse(mat3f(0.5)) == mat3f(2.f));
STATIC_REQUIRE(inverse(mat4f(0.5)) == mat4f(2.f));
STATIC_REQUIRE(inverse(float2x2(0.5)) == float2x2(2.f));
STATIC_REQUIRE(inverse(float3x3(0.5)) == float3x3(2.f));
STATIC_REQUIRE(inverse(float4x4(0.5)) == float4x4(2.f));
STATIC_REQUIRE(inverse(translate(1.f,2.f,3.f)) == approx4x4(translate(-1.f,-2.f,-3.f)));
REQUIRE(inverse(rotate(0.5f,normalize(vec3f{1.f,2.f,3.f}))) == approx4x4(rotate(-0.5f,normalize(vec3f{1.f,2.f,3.f}))));
REQUIRE(inverse(mat3f(rotate(0.5f,normalize(vec3f{1.f,2.f,3.f})))) == approx3x3(mat3f(rotate(-0.5f,normalize(vec3f{1.f,2.f,3.f})))));
REQUIRE(inverse(mat2f(rotate(0.5f,vec3f{0,0,1}))) == approx2x2(mat2f(rotate(-0.5f,vec3f{0,0,1}))));
REQUIRE(inverse(rotate(0.5f,normalize(float3{1.f,2.f,3.f}))) == approx4x4(rotate(-0.5f,normalize(float3{1.f,2.f,3.f}))));
REQUIRE(inverse(float3x3(rotate(0.5f,normalize(float3{1.f,2.f,3.f})))) == approx3x3(float3x3(rotate(-0.5f,normalize(float3{1.f,2.f,3.f})))));
REQUIRE(inverse(float2x2(rotate(0.5f,float3{0,0,1}))) == approx2x2(float2x2(rotate(-0.5f,float3{0,0,1}))));
}
}
}

182
untests/vmath_mat_tests.cpp
View File

@@ -20,155 +20,155 @@ namespace
TEST_CASE("vmath/mat") {
SECTION("size/sizeof") {
STATIC_REQUIRE(mat2i{}.size == 2);
STATIC_REQUIRE(mat3i{}.size == 3);
STATIC_REQUIRE(mat4i{}.size == 4);
STATIC_REQUIRE(int2x2{}.size == 2);
STATIC_REQUIRE(int3x3{}.size == 3);
STATIC_REQUIRE(int4x4{}.size == 4);
STATIC_REQUIRE(sizeof(mat2i{}) == sizeof(int) * 2 * 2);
STATIC_REQUIRE(sizeof(mat3i{}) == sizeof(int) * 3 * 3);
STATIC_REQUIRE(sizeof(mat4i{}) == sizeof(int) * 4 * 4);
STATIC_REQUIRE(sizeof(int2x2{}) == sizeof(int) * 2 * 2);
STATIC_REQUIRE(sizeof(int3x3{}) == sizeof(int) * 3 * 3);
STATIC_REQUIRE(sizeof(int4x4{}) == sizeof(int) * 4 * 4);
}
SECTION("ctors") {
{
STATIC_REQUIRE(mat2i()[0] == vec2i(1,0));
STATIC_REQUIRE(mat2i()[1] == vec2i(0,1));
STATIC_REQUIRE(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(mat2i(1,2,3,4)[0] == vec2i(1,2));
STATIC_REQUIRE(mat2i(1,2,3,4)[1] == vec2i(3,4));
STATIC_REQUIRE(int2x2(1,2,3,4)[0] == int2(1,2));
STATIC_REQUIRE(int2x2(1,2,3,4)[1] == int2(3,4));
STATIC_REQUIRE(mat2i({1,2},{3,4})[0] == vec2i(1,2));
STATIC_REQUIRE(mat2i({1,2},{3,4})[1] == vec2i(3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4})[0] == int2(1,2));
STATIC_REQUIRE(int2x2({1,2},{3,4})[1] == int2(3,4));
}
{
constexpr mat2i v(1,2,3,4);
constexpr mat2i v2 = v;
STATIC_REQUIRE(v2 == mat2i(1,2,3,4));
constexpr int2x2 v(1,2,3,4);
constexpr int2x2 v2 = v;
STATIC_REQUIRE(v2 == int2x2(1,2,3,4));
}
{
constexpr mat2i v(1,2,3,4);
constexpr mat2i v2 = std::move(v);
STATIC_REQUIRE(v2 == mat2i(1,2,3,4));
constexpr int2x2 v(1,2,3,4);
constexpr int2x2 v2 = std::move(v);
STATIC_REQUIRE(v2 == int2x2(1,2,3,4));
}
{
STATIC_REQUIRE(mat2i() == mat2i(1,0,0,1));
STATIC_REQUIRE(mat2i(2) == mat2i(2,0,0,2));
STATIC_REQUIRE(mat2i(1,2,3,4) == mat2i(1,2,3,4));
STATIC_REQUIRE(mat2i({1,2},{3,4}) == mat2i(1,2,3,4));
STATIC_REQUIRE(mat2i(mat2i({1,2},{3,4})) == mat2i(1,2,3,4));
STATIC_REQUIRE(mat2i(mat3i({1,2,3},{4,5,6},{7,8,9})) == mat2i(1,2,4,5));
STATIC_REQUIRE(mat2i(mat4i({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == mat2i(1,2,5,6));
STATIC_REQUIRE(int2x2() == int2x2(1,0,0,1));
STATIC_REQUIRE(int2x2(2) == int2x2(2,0,0,2));
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2({1,2},{3,4}) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(int2x2({1,2},{3,4})) == int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(int3x3({1,2,3},{4,5,6},{7,8,9})) == int2x2(1,2,4,5));
STATIC_REQUIRE(int2x2(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int2x2(1,2,5,6));
STATIC_REQUIRE(mat3i() == mat3i(1,0,0,0,1,0,0,0,1));
STATIC_REQUIRE(mat3i(2) == mat3i(2,0,0,0,2,0,0,0,2));
STATIC_REQUIRE(mat3i(1,2,3,4,5,6,7,8,9) == mat3i(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(mat3i({1,2,3},{4,5,6},{7,8,9}) == mat3i(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(mat3i(mat3i({1,2,3},{4,5,6},{7,8,9})) == mat3i(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(mat3i(mat2i({1,2},{3,4})) == mat3i(1,2,0,3,4,0,0,0,1));
STATIC_REQUIRE(mat3i(mat4i({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == mat3i(1,2,3,5,6,7,9,10,11));
STATIC_REQUIRE(int3x3() == int3x3(1,0,0,0,1,0,0,0,1));
STATIC_REQUIRE(int3x3(2) == int3x3(2,0,0,0,2,0,0,0,2));
STATIC_REQUIRE(int3x3(1,2,3,4,5,6,7,8,9) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3({1,2,3},{4,5,6},{7,8,9}) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3(int3x3({1,2,3},{4,5,6},{7,8,9})) == int3x3(1,2,3,4,5,6,7,8,9));
STATIC_REQUIRE(int3x3(int2x2({1,2},{3,4})) == int3x3(1,2,0,3,4,0,0,0,1));
STATIC_REQUIRE(int3x3(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int3x3(1,2,3,5,6,7,9,10,11));
STATIC_REQUIRE(mat4i() == mat4i(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(mat4i(2) == mat4i(2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,2));
STATIC_REQUIRE(mat4i(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == mat4i(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(mat4i({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}) == mat4i(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(mat4i(mat4i({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == mat4i(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(mat4i(mat2i({1,2},{3,4})) == mat4i(1,2,0,0,3,4,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(mat4i(mat3i({1,2,3},{4,5,6},{7,8,9})) == mat4i(1,2,3,0,4,5,6,0,7,8,9,0,0,0,0,1));
STATIC_REQUIRE(int4x4() == int4x4(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(int4x4(2) == int4x4(2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,2));
STATIC_REQUIRE(int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4(int4x4({1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16})) == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
STATIC_REQUIRE(int4x4(int2x2({1,2},{3,4})) == int4x4(1,2,0,0,3,4,0,0,0,0,1,0,0,0,0,1));
STATIC_REQUIRE(int4x4(int3x3({1,2,3},{4,5,6},{7,8,9})) == int4x4(1,2,3,0,4,5,6,0,7,8,9,0,0,0,0,1));
}
}
SECTION("operator=") {
{
mat2i v(1,2,3,4);
mat2i v2;
int2x2 v(1,2,3,4);
int2x2 v2;
v2 = v;
REQUIRE(v2 == mat2i(1,2,3,4));
REQUIRE(v2 == int2x2(1,2,3,4));
}
{
mat2i v(1,2,3,4);
mat2i v2;
int2x2 v(1,2,3,4);
int2x2 v2;
v2 = std::move(v);
REQUIRE(v2 == mat2i(1,2,3,4));
REQUIRE(v2 == int2x2(1,2,3,4));
}
}
SECTION("swap") {
{
mat2i v1(1,2,3,4);
mat2i v2(4,5,6,7);
int2x2 v1(1,2,3,4);
int2x2 v2(4,5,6,7);
v1.swap(v2);
REQUIRE(v1 == mat2i(4,5,6,7));
REQUIRE(v2 == mat2i(1,2,3,4));
REQUIRE(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4));
}
{
mat2i v1(1,2,3,4);
mat2i v2(4,5,6,7);
int2x2 v1(1,2,3,4);
int2x2 v2(4,5,6,7);
swap(v1, v2);
REQUIRE(v1 == mat2i(4,5,6,7));
REQUIRE(v2 == mat2i(1,2,3,4));
REQUIRE(v1 == int2x2(4,5,6,7));
REQUIRE(v2 == int2x2(1,2,3,4));
}
}
SECTION("operator[]") {
{
STATIC_REQUIRE(mat2i()[0] == vec2i(1,0));
STATIC_REQUIRE(mat2i()[1] == vec2i(0,1));
STATIC_REQUIRE(int2x2()[0] == int2(1,0));
STATIC_REQUIRE(int2x2()[1] == int2(0,1));
STATIC_REQUIRE(mat3i()[0] == vec3i(1,0,0));
STATIC_REQUIRE(mat3i()[1] == vec3i(0,1,0));
STATIC_REQUIRE(mat3i()[2] == vec3i(0,0,1));
STATIC_REQUIRE(int3x3()[0] == int3(1,0,0));
STATIC_REQUIRE(int3x3()[1] == int3(0,1,0));
STATIC_REQUIRE(int3x3()[2] == int3(0,0,1));
STATIC_REQUIRE(mat4i()[0] == vec4i(1,0,0,0));
STATIC_REQUIRE(mat4i()[1] == vec4i(0,1,0,0));
STATIC_REQUIRE(mat4i()[2] == vec4i(0,0,1,0));
STATIC_REQUIRE(mat4i()[3] == vec4i(0,0,0,1));
STATIC_REQUIRE(int4x4()[0] == int4(1,0,0,0));
STATIC_REQUIRE(int4x4()[1] == int4(0,1,0,0));
STATIC_REQUIRE(int4x4()[2] == int4(0,0,1,0));
STATIC_REQUIRE(int4x4()[3] == int4(0,0,0,1));
}
{
mat2i v;
v[0] = vec2i(1,2);
v[1] = vec2i(3,4);
REQUIRE(v == mat2i(1,2,3,4));
int2x2 v;
v[0] = int2(1,2);
v[1] = int2(3,4);
REQUIRE(v == int2x2(1,2,3,4));
}
{
mat3i v;
v[0] = vec3i(1,2,3);
v[1] = vec3i(4,5,6);
v[2] = vec3i(7,8,9);
REQUIRE(v == mat3i(1,2,3,4,5,6,7,8,9));
int3x3 v;
v[0] = int3(1,2,3);
v[1] = int3(4,5,6);
v[2] = int3(7,8,9);
REQUIRE(v == int3x3(1,2,3,4,5,6,7,8,9));
}
{
mat4i v;
v[0] = vec4i(1,2,3,4);
v[1] = vec4i(5,6,7,8);
v[2] = vec4i(9,10,11,12);
v[3] = vec4i(13,14,15,16);
REQUIRE(v == mat4i(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
int4x4 v;
v[0] = int4(1,2,3,4);
v[1] = int4(5,6,7,8);
v[2] = int4(9,10,11,12);
v[3] = int4(13,14,15,16);
REQUIRE(v == int4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16));
}
}
SECTION("at") {
STATIC_REQUIRE(mat2i(1,2,3,4).at(0) == vec2i(1,2));
STATIC_REQUIRE(mat2i(1,2,3,4).at(1) == vec2i(3,4));
REQUIRE_THROWS_AS(mat2i(1,2,3,4).at(2), std::out_of_range);
STATIC_REQUIRE(int2x2(1,2,3,4).at(0) == int2(1,2));
STATIC_REQUIRE(int2x2(1,2,3,4).at(1) == int2(3,4));
REQUIRE_THROWS_AS(int2x2(1,2,3,4).at(2), std::out_of_range);
}
SECTION("operator==/operator!=") {
STATIC_REQUIRE(mat2i(1,2,3,4) == mat2i(1,2,3,4));
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) == mat2i(2,2,3,4));
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) == mat2i(1,3,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) == int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) == int2x2(2,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) == int2x2(1,3,3,4));
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) != mat2i(1,2,3,4));
STATIC_REQUIRE(mat2i(1,2,3,4) != mat2i(2,2,3,4));
STATIC_REQUIRE(mat2i(1,2,3,4) != mat2i(1,3,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) != int2x2(1,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(2,2,3,4));
STATIC_REQUIRE(int2x2(1,2,3,4) != int2x2(1,3,3,4));
}
SECTION("operator<") {
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) < mat2i(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE(mat2i(1,1,3,4) < mat2i(1,2,3,4));
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) < mat2i(1,1,3,4));
STATIC_REQUIRE(int2x2(1,1,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(1,1,3,4));
STATIC_REQUIRE(mat2i(0,3,3,4) < mat2i(1,2,3,4));
STATIC_REQUIRE_FALSE(mat2i(1,2,3,4) < mat2i(0,3,3,4));
STATIC_REQUIRE(int2x2(0,3,3,4) < int2x2(1,2,3,4));
STATIC_REQUIRE_FALSE(int2x2(1,2,3,4) < int2x2(0,3,3,4));
}
}

54
untests/vmath_vec_ext_tests.cpp
View File

@@ -19,48 +19,48 @@ namespace
TEST_CASE("vmath/vec_ext") {
SECTION("units") {
STATIC_REQUIRE(zero2<int>() == vec2i(0,0));
STATIC_REQUIRE(zero3<int>() == vec3i(0,0,0));
STATIC_REQUIRE(zero4<int>() == vec4i(0,0,0,0));
STATIC_REQUIRE(zero2<int>() == int2(0,0));
STATIC_REQUIRE(zero3<int>() == int3(0,0,0));
STATIC_REQUIRE(zero4<int>() == int4(0,0,0,0));
STATIC_REQUIRE(unit2<int>() == vec2i(1,1));
STATIC_REQUIRE(unit2_x<int>() == vec2i(1,0));
STATIC_REQUIRE(unit2_y<int>() == vec2i(0,1));
STATIC_REQUIRE(unit2<int>() == int2(1,1));
STATIC_REQUIRE(unit2_x<int>() == int2(1,0));
STATIC_REQUIRE(unit2_y<int>() == int2(0,1));
STATIC_REQUIRE(unit3<int>() == vec3i(1,1,1));
STATIC_REQUIRE(unit3_x<int>() == vec3i(1,0,0));
STATIC_REQUIRE(unit3_y<int>() == vec3i(0,1,0));
STATIC_REQUIRE(unit3_z<int>() == vec3i(0,0,1));
STATIC_REQUIRE(unit3<int>() == int3(1,1,1));
STATIC_REQUIRE(unit3_x<int>() == int3(1,0,0));
STATIC_REQUIRE(unit3_y<int>() == int3(0,1,0));
STATIC_REQUIRE(unit3_z<int>() == int3(0,0,1));
STATIC_REQUIRE(unit4<int>() == vec4i(1,1,1,1));
STATIC_REQUIRE(unit4_x<int>() == vec4i(1,0,0,0));
STATIC_REQUIRE(unit4_y<int>() == vec4i(0,1,0,0));
STATIC_REQUIRE(unit4_z<int>() == vec4i(0,0,1,0));
STATIC_REQUIRE(unit4_w<int>() == vec4i(0,0,0,1));
STATIC_REQUIRE(unit4<int>() == int4(1,1,1,1));
STATIC_REQUIRE(unit4_x<int>() == int4(1,0,0,0));
STATIC_REQUIRE(unit4_y<int>() == int4(0,1,0,0));
STATIC_REQUIRE(unit4_z<int>() == int4(0,0,1,0));
STATIC_REQUIRE(unit4_w<int>() == int4(0,0,0,1));
}
SECTION("hash") {
REQUIRE(std::hash<vec2i>{}({1,2}) == std::hash<vec2i>{}({1,2}));
REQUIRE_FALSE(std::hash<vec2i>{}({1,2}) == std::hash<vec2i>{}({2,1}));
REQUIRE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({1,2}));
REQUIRE_FALSE(std::hash<int2>{}({1,2}) == std::hash<int2>{}({2,1}));
REQUIRE(std::hash<vec3i>{}({1,2,3}) == std::hash<vec3i>{}({1,2,3}));
REQUIRE_FALSE(std::hash<vec3i>{}({1,2,3}) == std::hash<vec3i>{}({3,2,1}));
REQUIRE(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({1,2,3}));
REQUIRE_FALSE(std::hash<int3>{}({1,2,3}) == std::hash<int3>{}({3,2,1}));
REQUIRE(std::hash<vec4i>{}({1,2,3,4}) == std::hash<vec4i>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<vec4i>{}({1,2,3,4}) == std::hash<vec4i>{}({3,2,1,4}));
REQUIRE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({1,2,3,4}));
REQUIRE_FALSE(std::hash<int4>{}({1,2,3,4}) == std::hash<int4>{}({3,2,1,4}));
}
SECTION("cast_to") {
constexpr auto v = cast_to<int>(vec2f{1.5f});
STATIC_REQUIRE(v == vec2i(1));
constexpr auto v = cast_to<int>(float2{1.5f});
STATIC_REQUIRE(v == int2(1));
STATIC_REQUIRE(std::is_same_v<decltype(v)::value_type, int>);
}
SECTION("component") {
STATIC_REQUIRE(component(vec2i{1,2}, 0) == 1);
STATIC_REQUIRE(component(vec2i{1,2}, 1) == 2);
STATIC_REQUIRE(component(int2{1,2}, 0) == 1);
STATIC_REQUIRE(component(int2{1,2}, 1) == 2);
STATIC_REQUIRE(component(vec2i{0,0}, 0, 1) == vec2i{1,0});
STATIC_REQUIRE(component(vec2i{0,0}, 1, 2) == vec2i{0,2});
STATIC_REQUIRE(component(int2{0,0}, 0, 1) == int2{1,0});
STATIC_REQUIRE(component(int2{0,0}, 1, 2) == int2{0,2});
}
}

240
untests/vmath_vec_fun_tests.cpp
View File

@@ -19,189 +19,189 @@ namespace
TEST_CASE("vmath/vec_fun") {
SECTION("Operators") {
STATIC_REQUIRE(-vec2i(1,-2) == vec2i(-1,2));
STATIC_REQUIRE(-int2(1,-2) == int2(-1,2));
STATIC_REQUIRE(vec2i(1,2) + 3 == vec2i(4,5));
STATIC_REQUIRE(vec2i(1,2) - 3 == vec2i(-2,-1));
STATIC_REQUIRE(vec2i(1,2) * 3 == vec2i(3,6));
STATIC_REQUIRE(vec2i(2,4) / 2 == vec2i(1,2));
STATIC_REQUIRE(int2(1,2) + 3 == int2(4,5));
STATIC_REQUIRE(int2(1,2) - 3 == int2(-2,-1));
STATIC_REQUIRE(int2(1,2) * 3 == int2(3,6));
STATIC_REQUIRE(int2(2,4) / 2 == int2(1,2));
STATIC_REQUIRE(3 + vec2i(1,2) == vec2i(4,5));
STATIC_REQUIRE(3 - vec2i(1,2) == vec2i(2,1));
STATIC_REQUIRE(3 * vec2i(1,2) == vec2i(3,6));
STATIC_REQUIRE(4 / vec2i(2,4) == vec2i(2,1));
STATIC_REQUIRE(3 + int2(1,2) == int2(4,5));
STATIC_REQUIRE(3 - int2(1,2) == int2(2,1));
STATIC_REQUIRE(3 * int2(1,2) == int2(3,6));
STATIC_REQUIRE(4 / int2(2,4) == int2(2,1));
STATIC_REQUIRE(vec2i(1,2) + vec2i(3,4) == vec2i(4,6));
STATIC_REQUIRE(vec2i(1,2) - vec2i(3,4) == vec2i(-2,-2));
STATIC_REQUIRE(vec2i(1,2) * vec2i(3,4) == vec2i(3,8));
STATIC_REQUIRE(vec2i(3,4) / vec2i(1,2) == vec2i(3,2));
STATIC_REQUIRE(int2(1,2) + int2(3,4) == int2(4,6));
STATIC_REQUIRE(int2(1,2) - int2(3,4) == int2(-2,-2));
STATIC_REQUIRE(int2(1,2) * int2(3,4) == int2(3,8));
STATIC_REQUIRE(int2(3,4) / int2(1,2) == int2(3,2));
{
vec2i v{1,2};
int2 v{1,2};
REQUIRE(&v == &(v += 3));
REQUIRE(v == vec2i{4,5});
REQUIRE(&v == &(v += vec2i{1,2}));
REQUIRE(v == vec2i{5,7});
REQUIRE(v == int2{4,5});
REQUIRE(&v == &(v += int2{1,2}));
REQUIRE(v == int2{5,7});
}
{
vec2i v{4,5};
int2 v{4,5};
REQUIRE(&v == &(v -= 3));
REQUIRE(v == vec2i{1,2});
REQUIRE(&v == &(v -= vec2i{2,4}));
REQUIRE(v == vec2i{-1,-2});
REQUIRE(v == int2{1,2});
REQUIRE(&v == &(v -= int2{2,4}));
REQUIRE(v == int2{-1,-2});
}
{
vec2i v{1,2};
int2 v{1,2};
REQUIRE(&v == &(v *= 3));
REQUIRE(v == vec2i{3,6});
REQUIRE(&v == &(v *= vec2i{2,3}));
REQUIRE(v == vec2i{6,18});
REQUIRE(v == int2{3,6});
REQUIRE(&v == &(v *= int2{2,3}));
REQUIRE(v == int2{6,18});
}
{
vec2i v{6,18};
int2 v{6,18};
REQUIRE(&v == &(v /= 2));
REQUIRE(v == vec2i{3,9});
REQUIRE(&v == &(v /= vec2i{3,4}));
REQUIRE(v == vec2i{1,2});
REQUIRE(v == int2{3,9});
REQUIRE(&v == &(v /= int2{3,4}));
REQUIRE(v == int2{1,2});
}
}
SECTION("Angle and Trigonometry Functions") {
STATIC_REQUIRE(radians(degrees(vec2f(12.13f))) == approx2(12.13f));
STATIC_REQUIRE(degrees(radians(vec2f(12.13f))) == approx2(12.13f));
STATIC_REQUIRE(radians(degrees(float2(12.13f))) == approx2(12.13f));
STATIC_REQUIRE(degrees(radians(float2(12.13f))) == approx2(12.13f));
(void)sin(vec2f(1.f));
(void)cos(vec2f(1.f));
(void)tan(vec2f(1.f));
(void)sin(float2(1.f));
(void)cos(float2(1.f));
(void)tan(float2(1.f));
(void)asin(vec2f(1.f));
(void)acos(vec2f(1.f));
(void)atan(vec2f(1.f));
(void)atan2(vec2f(1.f), vec2f(1.f));
(void)asin(float2(1.f));
(void)acos(float2(1.f));
(void)atan(float2(1.f));
(void)atan2(float2(1.f), float2(1.f));
(void)sinh(vec2f(1.f));
(void)cosh(vec2f(1.f));
(void)tanh(vec2f(1.f));
(void)sinh(float2(1.f));
(void)cosh(float2(1.f));
(void)tanh(float2(1.f));
(void)asinh(vec2f(1.f));
(void)acosh(vec2f(1.f));
(void)atanh(vec2f(1.f));
(void)asinh(float2(1.f));
(void)acosh(float2(1.f));
(void)atanh(float2(1.f));
}
SECTION("Exponential Functions") {
(void)pow(vec2f(1.f), vec2f(2.f));
(void)exp(vec2f(1.f));
(void)log(vec2f(1.f));
(void)exp2(vec2f(1.f));
(void)log2(vec2f(1.f));
(void)sqrt(vec2f(1.f));
(void)invsqrt(vec2f(1.f));
(void)pow(float2(1.f), float2(2.f));
(void)exp(float2(1.f));
(void)log(float2(1.f));
(void)exp2(float2(1.f));
(void)log2(float2(1.f));
(void)sqrt(float2(1.f));
(void)invsqrt(float2(1.f));
}
SECTION("Common Functions") {
REQUIRE(abs(vec2f(1.f, -1.f)) == approx2(1.f,1.f));
REQUIRE(sign(vec3f(1.f, -1.f, 0.f)) == approx3(1.f,-1.f,0.f));
REQUIRE(abs(float2(1.f, -1.f)) == approx2(1.f,1.f));
REQUIRE(sign(float3(1.f, -1.f, 0.f)) == approx3(1.f,-1.f,0.f));
(void)floor(vec2f(1.f, -1.f));
(void)trunc(vec2f(1.f, -1.f));
(void)round(vec2f(1.f, -1.f));
(void)ceil(vec2f(1.f, -1.f));
(void)fract(vec2f(1.f, -1.f));
(void)floor(float2(1.f, -1.f));
(void)trunc(float2(1.f, -1.f));
(void)round(float2(1.f, -1.f));
(void)ceil(float2(1.f, -1.f));
(void)fract(float2(1.f, -1.f));
REQUIRE(fmod(vec2f(1.7f), 1.2f) == approx2(0.5f));
REQUIRE(fmod(vec2f(1.7f), vec2f(1.2f)) == approx2(0.5f));
REQUIRE(fmod(float2(1.7f), 1.2f) == approx2(0.5f));
REQUIRE(fmod(float2(1.7f), float2(1.2f)) == approx2(0.5f));
{
vec2f out_i{};
REQUIRE(modf(vec2f(1.7f), &out_i) == approx2(0.7f));
float2 out_i{};
REQUIRE(modf(float2(1.7f), &out_i) == approx2(0.7f));
REQUIRE(out_i.x == Approx(1.f));
}
STATIC_REQUIRE(min(vec2i(1,2)) == 1);
STATIC_REQUIRE(min(vec2i(1,2), 1) == vec2i(1,1));
STATIC_REQUIRE(min(vec2i(1,1), vec2i(0,2)) == vec2i(0,1));
STATIC_REQUIRE(min(int2(1,2)) == 1);
STATIC_REQUIRE(min(int2(1,2), 1) == int2(1,1));
STATIC_REQUIRE(min(int2(1,1), int2(0,2)) == int2(0,1));
STATIC_REQUIRE(max(vec2i(1,2)) == 2);
STATIC_REQUIRE(max(vec2i(1,2), 1) == vec2i(1,2));
STATIC_REQUIRE(max(vec2i(1,1), vec2i(0,2)) == vec2i(1,2));
STATIC_REQUIRE(max(int2(1,2)) == 2);
STATIC_REQUIRE(max(int2(1,2), 1) == int2(1,2));
STATIC_REQUIRE(max(int2(1,1), int2(0,2)) == int2(1,2));
STATIC_REQUIRE(clamp(vec2i(1,2), 0, 1) == vec2i(1,1));
STATIC_REQUIRE(clamp(vec2i(1,2), vec2i(0), vec2i(1)) == vec2i(1,1));
STATIC_REQUIRE(clamp(int2(1,2), 0, 1) == int2(1,1));
STATIC_REQUIRE(clamp(int2(1,2), int2(0), int2(1)) == int2(1,1));
STATIC_REQUIRE(saturate(vec3f(-1.f,0.5,1.5f)) == approx3(0.f,0.5f,1.f));
STATIC_REQUIRE(saturate(float3(-1.f,0.5,1.5f)) == approx3(0.f,0.5f,1.f));
STATIC_REQUIRE(lerp(vec2f(0.f), vec2f(10.f), 0.5f) == approx2(5.f));
STATIC_REQUIRE(lerp(vec2f(0.f), vec2f(10.f), vec2f(0.5f)) == approx2(5.f));
STATIC_REQUIRE(lerp(float2(0.f), float2(10.f), 0.5f) == approx2(5.f));
STATIC_REQUIRE(lerp(float2(0.f), float2(10.f), float2(0.5f)) == approx2(5.f));
STATIC_REQUIRE(step(0.5f, vec2f(0.4f)) == approx2(0.f));
STATIC_REQUIRE(step(0.5f, vec2f(0.6f)) == approx2(1.f));
STATIC_REQUIRE(step(vec2f(0.5f), vec2f(0.4f)) == approx2(0.f));
STATIC_REQUIRE(step(vec2f(0.5f), vec2f(0.6f)) == approx2(1.f));
STATIC_REQUIRE(step(0.5f, float2(0.4f)) == approx2(0.f));
STATIC_REQUIRE(step(0.5f, float2(0.6f)) == approx2(1.f));
STATIC_REQUIRE(step(float2(0.5f), float2(0.4f)) == approx2(0.f));
STATIC_REQUIRE(step(float2(0.5f), float2(0.6f)) == approx2(1.f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, vec2f(0.1f)) == approx2(0.028f));
STATIC_REQUIRE(smoothstep(vec2f(0.f), vec2f(1.f), vec2f(0.1f)) == approx2(0.028f));
STATIC_REQUIRE(smoothstep(0.f, 1.f, float2(0.1f)) == approx2(0.028f));
STATIC_REQUIRE(smoothstep(float2(0.f), float2(1.f), float2(0.1f)) == approx2(0.028f));
REQUIRE_FALSE(isnan(vec2f(1.f)).x);
REQUIRE_FALSE(isinf(vec2f(1.f)).x);
REQUIRE(isfinite(vec2f(1.f)).x);
REQUIRE_FALSE(isnan(float2(1.f)).x);
REQUIRE_FALSE(isinf(float2(1.f)).x);
REQUIRE(isfinite(float2(1.f)).x);
REQUIRE_FALSE(fma(vec2f(2.f), vec2f(3.f), vec2f(4.f)).x == Approx(12.f));
REQUIRE_FALSE(fma(float2(2.f), float2(3.f), float2(4.f)).x == Approx(12.f));
{
vec2i out_exp{};
REQUIRE(frexp(vec2f(1.7f), &out_exp).x == Approx(0.85f));
REQUIRE(out_exp == vec2i(1));
int2 out_exp{};
REQUIRE(frexp(float2(1.7f), &out_exp).x == Approx(0.85f));
REQUIRE(out_exp == int2(1));
}
REQUIRE(ldexp(vec2f(0.85f), vec2i(1)).x == Approx(1.7f));
REQUIRE(ldexp(float2(0.85f), int2(1)).x == Approx(1.7f));
}
SECTION("Geometric Functions") {
REQUIRE(length(vec2f(10.f,0.f)) == Approx(10.f));
REQUIRE(length(vec2f(-10.f,0.f)) == Approx(10.f));
REQUIRE(length(float2(10.f,0.f)) == Approx(10.f));
REQUIRE(length(float2(-10.f,0.f)) == Approx(10.f));
STATIC_REQUIRE(length2(vec2f(10.f,0.f)) == approx(100.f));
STATIC_REQUIRE(length2(vec2f(-10.f,0.f)) == approx(100.f));
STATIC_REQUIRE(length2(float2(10.f,0.f)) == approx(100.f));
STATIC_REQUIRE(length2(float2(-10.f,0.f)) == approx(100.f));
REQUIRE(distance(vec2f(5.f,0.f), vec2f(10.f,0.f)) == Approx(5.f));
REQUIRE(distance(vec2f(-5.f,0.f), vec2f(-10.f,0.f)) == Approx(5.f));
REQUIRE(distance(float2(5.f,0.f), float2(10.f,0.f)) == Approx(5.f));
REQUIRE(distance(float2(-5.f,0.f), float2(-10.f,0.f)) == Approx(5.f));
STATIC_REQUIRE(distance2(vec2f(5.f,0.f), vec2f(10.f,0.f)) == approx(25.f));
STATIC_REQUIRE(distance2(vec2f(-5.f,0.f), vec2f(-10.f,0.f)) == approx(25.f));
STATIC_REQUIRE(distance2(float2(5.f,0.f), float2(10.f,0.f)) == approx(25.f));
STATIC_REQUIRE(distance2(float2(-5.f,0.f), float2(-10.f,0.f)) == approx(25.f));
STATIC_REQUIRE(dot(vec2i(1,2),vec2i(3,4)) == 11);
STATIC_REQUIRE(cross(vec2i(1,0),vec2i(0,1)) == 1);
STATIC_REQUIRE(cross(vec3i(1,0,0),vec3i(0,1,0)) == vec3i(0,0,1));
REQUIRE(normalize(vec2f(0.5f,0.f)).x == Approx(1.f));
STATIC_REQUIRE(dot(int2(1,2),int2(3,4)) == 11);
STATIC_REQUIRE(cross(int2(1,0),int2(0,1)) == 1);
STATIC_REQUIRE(cross(int3(1,0,0),int3(0,1,0)) == int3(0,0,1));
REQUIRE(normalize(float2(0.5f,0.f)).x == Approx(1.f));
STATIC_REQUIRE(faceforward(vec2f(1.f), vec2f(2.f), vec2f(3.f)).x == approx(-1.f));
STATIC_REQUIRE(reflect(vec2f(1.f), vec2f(2.f)).x == approx(-15.f));
REQUIRE(refract(vec2f(1.f), vec2f(2.f), 1.f).x == Approx(-15.f));
STATIC_REQUIRE(faceforward(float2(1.f), float2(2.f), float2(3.f)).x == approx(-1.f));
STATIC_REQUIRE(reflect(float2(1.f), float2(2.f)).x == approx(-15.f));
REQUIRE(refract(float2(1.f), float2(2.f), 1.f).x == Approx(-15.f));
}
SECTION("Vector Relational Functions") {
STATIC_REQUIRE(less(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(false, false, true));
STATIC_REQUIRE(less_equal(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(false, true, true));
STATIC_REQUIRE(less(int3(1,1,1), int3(0,1,2)) == bool3(false, false, true));
STATIC_REQUIRE(less_equal(int3(1,1,1), int3(0,1,2)) == bool3(false, true, true));
STATIC_REQUIRE(greater(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(true, false, false));
STATIC_REQUIRE(greater_equal(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(true, true, false));
STATIC_REQUIRE(greater(int3(1,1,1), int3(0,1,2)) == bool3(true, false, false));
STATIC_REQUIRE(greater_equal(int3(1,1,1), int3(0,1,2)) == bool3(true, true, false));
STATIC_REQUIRE(equal_to(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(false, true, false));
STATIC_REQUIRE(not_equal_to(vec3i(1,1,1), vec3i(0,1,2)) == vec3b(true, false, true));
STATIC_REQUIRE(equal_to(int3(1,1,1), int3(0,1,2)) == bool3(false, true, false));
STATIC_REQUIRE(not_equal_to(int3(1,1,1), int3(0,1,2)) == bool3(true, false, true));
STATIC_REQUIRE_FALSE(any(vec2b(false, false)));
STATIC_REQUIRE(any(vec2b(true, false)));
STATIC_REQUIRE(any(vec2b(false, true)));
STATIC_REQUIRE(any(vec2b(true, true)));
STATIC_REQUIRE_FALSE(any(bool2(false, false)));
STATIC_REQUIRE(any(bool2(true, false)));
STATIC_REQUIRE(any(bool2(false, true)));
STATIC_REQUIRE(any(bool2(true, true)));
STATIC_REQUIRE_FALSE(all(vec2b(false, false)));
STATIC_REQUIRE_FALSE(all(vec2b(true, false)));
STATIC_REQUIRE_FALSE(all(vec2b(false, true)));
STATIC_REQUIRE(all(vec2b(true, true)));
STATIC_REQUIRE_FALSE(all(bool2(false, false)));
STATIC_REQUIRE_FALSE(all(bool2(true, false)));
STATIC_REQUIRE_FALSE(all(bool2(false, true)));
STATIC_REQUIRE(all(bool2(true, true)));
STATIC_REQUIRE(not_(vec2b(false, false)) == vec2b(true, true));
STATIC_REQUIRE(not_(vec2b(true, false)) == vec2b(false, true));
STATIC_REQUIRE(not_(vec2b(false, true)) == vec2b(true, false));
STATIC_REQUIRE(not_(vec2b(true, true)) == vec2b(false, false));
STATIC_REQUIRE(not_(bool2(false, false)) == bool2(true, true));
STATIC_REQUIRE(not_(bool2(true, false)) == bool2(false, true));
STATIC_REQUIRE(not_(bool2(false, true)) == bool2(true, false));
STATIC_REQUIRE(not_(bool2(true, true)) == bool2(false, false));
}
}

164
untests/vmath_vec_tests.cpp
View File

@@ -20,157 +20,157 @@ namespace
TEST_CASE("vmath/vec") {
SECTION("size/sizeof") {
STATIC_REQUIRE(vec2i{}.size == 2);
STATIC_REQUIRE(vec3i{}.size == 3);
STATIC_REQUIRE(vec4i{}.size == 4);
STATIC_REQUIRE(int2{}.size == 2);
STATIC_REQUIRE(int3{}.size == 3);
STATIC_REQUIRE(int4{}.size == 4);
STATIC_REQUIRE(sizeof(vec2i{}) == sizeof(int) * 2);
STATIC_REQUIRE(sizeof(vec3i{}) == sizeof(int) * 3);
STATIC_REQUIRE(sizeof(vec4i{}) == sizeof(int) * 4);
STATIC_REQUIRE(sizeof(int2{}) == sizeof(int) * 2);
STATIC_REQUIRE(sizeof(int3{}) == sizeof(int) * 3);
STATIC_REQUIRE(sizeof(int4{}) == sizeof(int) * 4);
}
SECTION("ctors") {
{
STATIC_REQUIRE(vec2i().x == 0);
STATIC_REQUIRE(vec2i().y == 0);
STATIC_REQUIRE(int2().x == 0);
STATIC_REQUIRE(int2().y == 0);
STATIC_REQUIRE(vec2i(1).x == 1);
STATIC_REQUIRE(vec2i(1).y == 1);
STATIC_REQUIRE(int2(1).x == 1);
STATIC_REQUIRE(int2(1).y == 1);
STATIC_REQUIRE(vec2i(1,2).x == 1);
STATIC_REQUIRE(vec2i(1,2).y == 2);
STATIC_REQUIRE(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2);
}
{
constexpr vec2i v(1,2);
constexpr vec2i v2 = v;
STATIC_REQUIRE(v2 == vec2i(1,2));
constexpr int2 v(1,2);
constexpr int2 v2 = v;
STATIC_REQUIRE(v2 == int2(1,2));
}
{
constexpr vec2i v(1,2);
constexpr vec2i v2 = std::move(v);
STATIC_REQUIRE(v2 == vec2i(1,2));
constexpr int2 v(1,2);
constexpr int2 v2 = std::move(v);
STATIC_REQUIRE(v2 == int2(1,2));
}
{
STATIC_REQUIRE(vec2i(1) == vec2i(1,1));
STATIC_REQUIRE(vec2i(1,2) == vec2i(1,2));
STATIC_REQUIRE(vec2i(vec2i(1,2)) == vec2i(1,2));
STATIC_REQUIRE(vec2i(vec3i(1,2,3)) == vec2i(1,2));
STATIC_REQUIRE(vec2i(vec4i(1,2,3,4)) == vec2i(1,2));
STATIC_REQUIRE(int2(1) == int2(1,1));
STATIC_REQUIRE(int2(1,2) == int2(1,2));
STATIC_REQUIRE(int2(int2(1,2)) == int2(1,2));
STATIC_REQUIRE(int2(int3(1,2,3)) == int2(1,2));
STATIC_REQUIRE(int2(int4(1,2,3,4)) == int2(1,2));
STATIC_REQUIRE(vec3i(1) == vec3i(1,1,1));
STATIC_REQUIRE(vec3i(1,2,3) == vec3i(1,2,3));
STATIC_REQUIRE(vec3i(vec2i(1,2),3) == vec3i(1,2,3));
STATIC_REQUIRE(vec3i(1,vec2i(2,3)) == vec3i(1,2,3));
STATIC_REQUIRE(vec3i(vec3i(1,2,3)) == vec3i(1,2,3));
STATIC_REQUIRE(vec3i(vec4i(1,2,3,4)) == vec3i(1,2,3));
STATIC_REQUIRE(int3(1) == int3(1,1,1));
STATIC_REQUIRE(int3(1,2,3) == int3(1,2,3));
STATIC_REQUIRE(int3(int2(1,2),3) == int3(1,2,3));
STATIC_REQUIRE(int3(1,int2(2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int3(1,2,3)) == int3(1,2,3));
STATIC_REQUIRE(int3(int4(1,2,3,4)) == int3(1,2,3));
STATIC_REQUIRE(vec4i(1) == vec4i(1,1,1,1));
STATIC_REQUIRE(vec4i(1,2,3,4) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(vec2i(1,2),3,4) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(1,vec2i(2,3),4) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(1,2,vec2i(3,4)) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(vec2i(1,2),vec2i(3,4)) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(vec3i(1,2,3),4) == vec4i(1,2,3,4));
STATIC_REQUIRE(vec4i(1,vec3i(2,3,4)) == vec4i(1,2,3,4));
STATIC_REQUIRE(int4(1) == int4(1,1,1,1));
STATIC_REQUIRE(int4(1,2,3,4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int2(1,2),3,4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,int2(2,3),4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,2,int2(3,4)) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int2(1,2),int2(3,4)) == int4(1,2,3,4));
STATIC_REQUIRE(int4(int3(1,2,3),4) == int4(1,2,3,4));
STATIC_REQUIRE(int4(1,int3(2,3,4)) == int4(1,2,3,4));
}
}
SECTION("operator=") {
{
vec2i v(1,2);
vec2i v2;
int2 v(1,2);
int2 v2;
v2 = v;
REQUIRE(v2 == vec2i(1,2));
REQUIRE(v2 == int2(1,2));
}
{
vec2i v(1,2);
vec2i v2;
int2 v(1,2);
int2 v2;
v2 = std::move(v);
REQUIRE(v2 == vec2i(1,2));
REQUIRE(v2 == int2(1,2));
}
}
SECTION("swap") {
{
vec2i v1(1,2);
vec2i v2(4,5);
int2 v1(1,2);
int2 v2(4,5);
v1.swap(v2);
REQUIRE(v1 == vec2i(4,5));
REQUIRE(v2 == vec2i(1,2));
REQUIRE(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2));
}
{
vec2i v1(1,2);
vec2i v2(4,5);
int2 v1(1,2);
int2 v2(4,5);
swap(v1, v2);
REQUIRE(v1 == vec2i(4,5));
REQUIRE(v2 == vec2i(1,2));
REQUIRE(v1 == int2(4,5));
REQUIRE(v2 == int2(1,2));
}
}
SECTION("operator[]") {
{
STATIC_REQUIRE(vec2i(1,2).x == 1);
STATIC_REQUIRE(vec2i(1,2).y == 2);
STATIC_REQUIRE(int2(1,2).x == 1);
STATIC_REQUIRE(int2(1,2).y == 2);
STATIC_REQUIRE(vec3i(1,2,3).x == 1);
STATIC_REQUIRE(vec3i(1,2,3).y == 2);
STATIC_REQUIRE(vec3i(1,2,3).z == 3);
STATIC_REQUIRE(int3(1,2,3).x == 1);
STATIC_REQUIRE(int3(1,2,3).y == 2);
STATIC_REQUIRE(int3(1,2,3).z == 3);
STATIC_REQUIRE(vec4i(1,2,3,4).x == 1);
STATIC_REQUIRE(vec4i(1,2,3,4).y == 2);
STATIC_REQUIRE(vec4i(1,2,3,4).z == 3);
STATIC_REQUIRE(vec4i(1,2,3,4).w == 4);
STATIC_REQUIRE(int4(1,2,3,4).x == 1);
STATIC_REQUIRE(int4(1,2,3,4).y == 2);
STATIC_REQUIRE(int4(1,2,3,4).z == 3);
STATIC_REQUIRE(int4(1,2,3,4).w == 4);
}
{
STATIC_REQUIRE(vec2i(1,2)[0] == 1);
STATIC_REQUIRE(vec2i(1,2)[1] == 2);
STATIC_REQUIRE(int2(1,2)[0] == 1);
STATIC_REQUIRE(int2(1,2)[1] == 2);
}
{
vec2i v;
int2 v;
v.x = 1;
v.y = 2;
REQUIRE(v == vec2i(1,2));
REQUIRE(v == int2(1,2));
}
{
vec3i v;
int3 v;
v.x = 1;
v.y = 2;
v.z = 3;
REQUIRE(v == vec3i(1,2,3));
REQUIRE(v == int3(1,2,3));
}
{
vec4i v;
int4 v;
v.x = 1;
v.y = 2;
v.z = 3;
v.w = 4;
REQUIRE(v == vec4i(1,2,3,4));
REQUIRE(v == int4(1,2,3,4));
}
}
SECTION("at") {
STATIC_REQUIRE(vec2i(1,2).at(0) == 1);
STATIC_REQUIRE(vec2i(1,2).at(1) == 2);
REQUIRE_THROWS_AS(vec2i(1,2).at(2), std::out_of_range);
STATIC_REQUIRE(int2(1,2).at(0) == 1);
STATIC_REQUIRE(int2(1,2).at(1) == 2);
REQUIRE_THROWS_AS(int2(1,2).at(2), std::out_of_range);
}
SECTION("operator==/operator!=") {
STATIC_REQUIRE(vec2i(1,2) == vec2i(1,2));
STATIC_REQUIRE_FALSE(vec2i(1,2) == vec2i(2,2));
STATIC_REQUIRE_FALSE(vec2i(1,2) == vec2i(1,3));
STATIC_REQUIRE(int2(1,2) == int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(2,2));
STATIC_REQUIRE_FALSE(int2(1,2) == int2(1,3));
STATIC_REQUIRE_FALSE(vec2i(1,2) != vec2i(1,2));
STATIC_REQUIRE(vec2i(1,2) != vec2i(2,2));
STATIC_REQUIRE(vec2i(1,2) != vec2i(1,3));
STATIC_REQUIRE_FALSE(int2(1,2) != int2(1,2));
STATIC_REQUIRE(int2(1,2) != int2(2,2));
STATIC_REQUIRE(int2(1,2) != int2(1,3));
}
SECTION("operator<") {
STATIC_REQUIRE_FALSE(vec2i(1,2) < vec2i(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(1,2));
STATIC_REQUIRE(vec2i(1,1) < vec2i(1,2));
STATIC_REQUIRE_FALSE(vec2i(1,2) < vec2i(1,1));
STATIC_REQUIRE(int2(1,1) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(1,1));
STATIC_REQUIRE(vec2i(0,3) < vec2i(1,2));
STATIC_REQUIRE_FALSE(vec2i(1,2) < vec2i(0,3));
STATIC_REQUIRE(int2(0,3) < int2(1,2));
STATIC_REQUIRE_FALSE(int2(1,2) < int2(0,3));
}
}