mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-22 08:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixes for tests build

Browse Source
This commit is contained in:
Christophe 2023-12-19 20:06:43 +01:00 committed by Christophe
parent b90333c124
commit 2d38c41161
10 changed files with 407 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
.github/workflows/ci.yml vendored
View File

@ -2,14 +2,13 @@ name: ci
run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
on: [push]
jobs:
Pure:
runs-on: ${{ matrix.os}}
windows-latest:
runs-on: windows-latest
strategy:
fail-fast: false
matrix:
std: [98, 11, 14, 17, 20]
config: [Debug, Release]
os: [ubuntu-latest, macos-latest, windows-latest]
steps:
- run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
- run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
@ -22,10 +21,140 @@ jobs:
run: |
ls ${{ github.workspace }}
- run: echo "🍏 This job's status is ${{ job.status }}."
#- run: cmake -S. -B ./build_98_pure -D GLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_FORCE_PURE=ON -DCMAKE_BUILD_TYPE=${{matrix.config}}
- run: cmake -S. -B ./build_auto -DCMAKE_BUILD_TYPE=${{matrix.config}}
- run: cmake --build ./build_auto --parallel --config ${{matrix.config}}
- run: ctest --parallel 4 --verbose -C ${{matrix.config}} --test-dir ./build_auto
- name: CMake Version
run: cmake --version
- run: cmake -S. -B ./build_pure_98_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_pure_98_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_98_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_sse2_98_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_pure_11_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_pure_11_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_11_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_sse2_11_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
#- run: cmake -S. -B ./build_avx2_std -DGLM_TEST_ENABLE_SIMD_AVX=ON
#- run: cmake -S. -B ./build_avx2_ext -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake --build ./build_pure_98_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_ext --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_std --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_ext --config ${{matrix.config}}
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_ext
#- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_avx2_std
#- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_avx2_ext
ubuntu-latest:
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
config: [Debug, Release]
steps:
- run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
- run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
- run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
- name: Check out repository code
uses: actions/checkout@v4
- run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
- run: echo "🖥️ The workflow is now ready to test your code on the runner."
- name: List files in the repository
run: |
ls ${{ github.workspace }}
- run: echo "🍏 This job's status is ${{ job.status }}."
- name: GCC Version
run: gcc --version
- name: CMake Version
run: cmake --version
- run: cmake -S. -B ./build_pure_98_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_pure_98_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_98_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_sse2_98_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_pure_11_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_pure_11_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_11_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_sse2_11_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
#- run: cmake -S. -B ./build_avx2_std -DGLM_TEST_ENABLE_SIMD_AVX=ON
#- run: cmake -S. -B ./build_avx2_ext -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake --build ./build_pure_98_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_ext --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_std --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_ext --config ${{matrix.config}}
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_ext
macos-latest:
runs-on: macos-latest
strategy:
fail-fast: false
matrix:
config: [Debug, Release]
steps:
- run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
- run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
- run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
- name: Check out repository code
uses: actions/checkout@v4
- run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
- run: echo "🖥️ The workflow is now ready to test your code on the runner."
- name: List files in the repository
run: |
ls ${{ github.workspace }}
- run: echo "🍏 This job's status is ${{ job.status }}."
- name: CMake Version
run: cmake --version
- name: Clang Version
run: clang --version
- run: cmake -S. -B ./build_pure_98_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_pure_98_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_98_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON
- run: cmake -S. -B ./build_sse2_98_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_98=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_pure_11_std -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_pure_11_ext -DGLM_TEST_FORCE_PURE=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake -S. -B ./build_sse2_11_std -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON
- run: cmake -S. -B ./build_sse2_11_ext -DGLM_TEST_ENABLE_SIMD_SSE2=ON -DGLM_TEST_ENABLE_CXX_11=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
#- run: cmake -S. -B ./build_avx2_std -DGLM_TEST_ENABLE_SIMD_AVX=ON
#- run: cmake -S. -B ./build_avx2_ext -DGLM_TEST_ENABLE_SIMD_AVX=ON -DGLM_TEST_ENABLE_LANG_EXTENSIONS=ON
- run: cmake --build ./build_pure_98_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_98_ext --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_std --config ${{matrix.config}}
- run: cmake --build ./build_pure_11_ext --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_std --config ${{matrix.config}}
- run: cmake --build ./build_sse2_11_ext --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_std --config ${{matrix.config}}
#- run: cmake --build ./build_avx2_ext --config ${{matrix.config}}
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_98_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_pure_11_ext
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_std
- run: ctest --verbose -C ${{matrix.config}} --test-dir ./build_sse2_11_ext
#name: GLM Unit Tests

4
glm/detail/setup.hpp
View File

@ -82,8 +82,8 @@
#if (defined(GLM_FORCE_CXX_UNKNOWN))
# define GLM_LANG 0
#elif defined(GLM_FORCE_CXX2A)
# define GLM_LANG (GLM_LANG_CXX2A | GLM_LANG_EXT)
#elif defined(GLM_FORCE_CXX20)
# define GLM_LANG (GLM_LANG_CXX20 | GLM_LANG_EXT)
# define GLM_LANG_STL11_FORCED
#elif defined(GLM_FORCE_CXX17)
# define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)

278
glm/detail/type_vec4_simd.inl
View File

@ -54,7 +54,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
{
vec<4, float, Q> Result;
Result.data = _mm_add_ps((glm_f32vec4)a.data, (glm_f32vec4)b.data);
Result.data = _mm_add_ps(a.data, b.data);
return Result;
}
};
@ -78,7 +78,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
{
vec<4, float, Q> Result;
Result.data = _mm_sub_ps((glm_f32vec4)a.data, (glm_f32vec4)b.data);
Result.data = _mm_sub_ps(a.data, b.data);
return Result;
}
};
@ -90,7 +90,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
{
vec<4, double, Q> Result;
Result.data = _mm256_sub_pd((glm_f64vec4)a.data, (glm_f64vec4)b.data);
Result.data = _mm256_sub_pd(a.data, b.data);
return Result;
}
};
@ -102,7 +102,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
{
vec<4, float, Q> Result;
Result.data = _mm_mul_ps((glm_f32vec4)a.data, (glm_f32vec4)b.data);
Result.data = _mm_mul_ps(a.data, b.data);
return Result;
}
};
@ -114,7 +114,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
{
vec<4, double, Q> Result;
Result.data = _mm256_mul_pd((glm_f64vec4)a.data, (glm_f64vec4)b.data);
Result.data = _mm256_mul_pd(a.data, b.data);
return Result;
}
};
@ -126,19 +126,19 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b)
{
vec<4, float, Q> Result;
Result.data = _mm_div_ps((glm_f32vec4)a.data, (glm_f32vec4)b.data);
Result.data = _mm_div_ps(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<qualifier Q>
struct compute_vec4_div<double, Q, true>
{
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b)
{
vec<4, double, Q> Result;
Result.data = _mm256_div_pd((glm_f64vec4)a.data, (glm_f64vec4)b.data);
Result.data = _mm256_div_pd(a.data, b.data);
return Result;
}
};
@ -150,150 +150,282 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& a, vec<4, float, aligned_lowp> const& b)
{
vec<4, float, aligned_lowp> Result;
Result.data = _mm_mul_ps((glm_f32vec4)a.data, _mm_rcp_ps(b.data));
Result.data = _mm_mul_ps(a.data, _mm_rcp_ps(b.data));
return Result;
}
};
template<typename T, qualifier Q>
struct compute_vec4_and<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_and<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm_and_si128((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int, Q> Result;
Result.data = _mm_and_si128(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_and<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, uint, Q> Result;
Result.data = _mm_and_si128(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_and<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_and<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& a, vec<4, int64, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm256_and_si256((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int64, Q> Result;
Result.data = _mm256_and_si256(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_and<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& a, vec<4, uint64, Q> const& b)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_and_si256(a.data, b.data);
return Result;
}
};
# endif
template<typename T, qualifier Q>
struct compute_vec4_or<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_or<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm_or_si128((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int, Q> Result;
Result.data = _mm_or_si128(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_or<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
{
vec<4, uint, Q> Result;
Result.data = _mm_or_si128(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_or<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_or<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& a, vec<4, int64, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm256_or_si256((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int64, Q> Result;
Result.data = _mm256_or_si256(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_or<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& a, vec<4, uint64, Q> const& b)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_or_si256(a.data, b.data);
return Result;
}
};
# endif
template<typename T, qualifier Q>
struct compute_vec4_xor<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_xor<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm_xor_si128((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int, Q> Result;
Result.data = _mm_xor_si128(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_xor<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
{
vec<4, uint, Q> Result;
Result.data = _mm_xor_si128(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_xor<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_xor<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& a, vec<4, int64, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm256_xor_si256((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int64, Q> Result;
Result.data = _mm256_xor_si256(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_xor<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& a, vec<4, uint64, Q> const& b)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_xor_si256(a.data, b.data);
return Result;
}
};
# endif
template<typename T, qualifier Q>
struct compute_vec4_shift_left<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_shift_left<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm_sll_epi32((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int, Q> Result;
Result.data = _mm_sll_epi32(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_shift_left<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
{
vec<4, uint, Q> Result;
Result.data = _mm_sll_epi32(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_shift_left<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_shift_left<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& a, vec<4, int64, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm256_sll_epi64((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int64, Q> Result;
Result.data = _mm256_sll_epi64(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_shift_left<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& a, vec<4, uint64, Q> const& b)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_sll_epi64(a.data, b.data);
return Result;
}
};
# endif
template<typename T, qualifier Q>
struct compute_vec4_shift_right<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_shift_right<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& a, vec<4, int, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm_srl_epi32((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int, Q> Result;
Result.data = _mm_srl_epi32(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_shift_right<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& a, vec<4, uint, Q> const& b)
{
vec<4, uint, Q> Result;
Result.data = _mm_srl_epi32(a.data, b.data);
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_shift_right<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_shift_right<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& a, vec<4, int64, Q> const& b)
{
vec<4, T, Q> Result;
Result.data = _mm256_srl_epi64((glm_f32vec4)a.data, (glm_f32vec4)b.data);
vec<4, int64, Q> Result;
Result.data = _mm256_srl_epi64(a.data, b.data);
return Result;
}
};
template<qualifier Q>
struct compute_vec4_shift_right<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& a, vec<4, uint64, Q> const& b)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_srl_epi64(a.data, b.data);
return Result;
}
};
# endif
template<typename T, qualifier Q>
struct compute_vec4_bitwise_not<T, Q, true, 32, true>
template<qualifier Q>
struct compute_vec4_bitwise_not<int, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& v)
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
{
vec<4, T, Q> Result;
Result.data = _mm_xor_si128((glm_f32vec4)v.data, _mm_set1_epi32(-1));
vec<4, int, Q> Result;
Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
return Result;
}
};
template<qualifier Q>
struct compute_vec4_bitwise_not<uint, Q, true, 32, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v)
{
vec<4, uint, Q> Result;
Result.data = _mm_xor_si128(v.data, _mm_set1_epi32(-1));
return Result;
}
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, qualifier Q>
struct compute_vec4_bitwise_not<T, Q, true, 64, true>
template<qualifier Q>
struct compute_vec4_bitwise_not<int64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, T, Q> call(vec<4, T, Q> const& v)
GLM_FUNC_QUALIFIER static vec<4, int64, Q> call(vec<4, int64, Q> const& v)
{
vec<4, T, Q> Result;
Result.data = _mm256_xor_si256((glm_f32vec4)v.data, _mm_set1_epi32(-1));
vec<4, int64, Q> Result;
Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
return Result;
}
};
template<qualifier Q>
struct compute_vec4_bitwise_not<uint64, Q, true, 64, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint64, Q> call(vec<4, uint64, Q> const& v)
{
vec<4, uint64, Q> Result;
Result.data = _mm256_xor_si256(v.data, _mm_set1_epi32(-1));
return Result;
}
};
@ -304,7 +436,7 @@ namespace detail
{
GLM_FUNC_QUALIFIER static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
{
return _mm_movemask_ps(_mm_cmpneq_ps((glm_f32vec4)v1.data, (glm_f32vec4)v2.data)) == 0;
return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) == 0;
}
};
@ -315,7 +447,7 @@ namespace detail
GLM_FUNC_QUALIFIER static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
{
//return _mm_movemask_epi8(_mm_cmpeq_epi32(v1.data, v2.data)) != 0;
__m128i neq = _mm_xor_si128((glm_f32vec4)v1.data, (glm_f32vec4)v2.data);
__m128i neq = _mm_xor_si128(v1.data, v2.data);
return _mm_test_all_zeros(neq, neq) == 0;
}
};
@ -326,7 +458,7 @@ namespace detail
{
GLM_FUNC_QUALIFIER static bool call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
{
return _mm_movemask_ps(_mm_cmpneq_ps((glm_f32vec4)v1.data, (glm_f32vec4)v2.data)) != 0;
return _mm_movemask_ps(_mm_cmpneq_ps(v1.data, v2.data)) != 0;
}
};
@ -337,7 +469,7 @@ namespace detail
GLM_FUNC_QUALIFIER static bool call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
{
//return _mm_movemask_epi8(_mm_cmpneq_epi32(v1.data, v2.data)) != 0;
__m128i neq = _mm_xor_si128((glm_f32vec4)v1.data, (glm_f32vec4)v2.data);
__m128i neq = _mm_xor_si128(v1.data, v2.data);
return _mm_test_all_zeros(neq, neq) != 0;
}
};

40
glm/gtx/hash.hpp
View File

@ -20,8 +20,6 @@
# endif
#endif
#include <functional>
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
@ -43,100 +41,106 @@
#include "../mat4x4.hpp"
#if !GLM_HAS_CXX11_STL
# error "GLM_GTX_hash requires C++11 standard library support"
#pragma message("GLM_GTX_hash requires C++11 standard library support")
#endif
#if 0 && GLM_LANG & GLM_LANG_CXX11
#define GLM_GTX_hash 1
#include <functional>
namespace std
{
template<typename T, glm::qualifier Q>
struct hash<glm::vec<1, T,Q> >
struct hash<glm::vec<1, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::vec<1, T, Q> const& v) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::vec<2, T,Q> >
struct hash<glm::vec<2, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::vec<2, T, Q> const& v) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::vec<3, T,Q> >
struct hash<glm::vec<3, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::vec<3, T, Q> const& v) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::vec<4, T,Q> >
struct hash<glm::vec<4, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::vec<4, T, Q> const& v) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::qua<T,Q>>
struct hash<glm::qua<T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::qua<T, Q> const& q) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::tdualquat<T,Q> >
struct hash<glm::tdualquat<T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::tdualquat<T,Q> const& q) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<2, 2, T,Q> >
struct hash<glm::mat<2, 2, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<2, 3, T,Q> >
struct hash<glm::mat<2, 3, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<2, 4, T,Q> >
struct hash<glm::mat<2, 4, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<3, 2, T,Q> >
struct hash<glm::mat<3, 2, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<3, 3, T,Q> >
struct hash<glm::mat<3, 3, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<3, 4, T,Q> >
struct hash<glm::mat<3, 4, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<4, 2, T,Q> >
struct hash<glm::mat<4, 2, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<4, 3, T,Q> >
struct hash<glm::mat<4, 3, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,Q> const& m) const GLM_NOEXCEPT;
};
template<typename T, glm::qualifier Q>
struct hash<glm::mat<4, 4, T,Q> >
struct hash<glm::mat<4, 4, T, Q> >
{
GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,Q> const& m) const GLM_NOEXCEPT;
};
} // namespace std
#include "hash.inl"
#endif //GLM_LANG & GLM_LANG_CXX11

30
glm/gtx/hash.inl
View File

@ -13,14 +13,14 @@ namespace detail
namespace std
{
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::vec<1, T, Q>>::operator()(glm::vec<1, T, Q> const& v) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::vec<1, T, Q> >::operator()(glm::vec<1, T, Q> const& v) const GLM_NOEXCEPT
{
hash<T> hasher;
return hasher(v.x);
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::vec<2, T, Q>>::operator()(glm::vec<2, T, Q> const& v) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::vec<2, T, Q> >::operator()(glm::vec<2, T, Q> const& v) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<T> hasher;
@ -30,7 +30,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::vec<3, T, Q>>::operator()(glm::vec<3, T, Q> const& v) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::vec<3, T, Q> >::operator()(glm::vec<3, T, Q> const& v) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<T> hasher;
@ -41,7 +41,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::vec<4, T, Q>>::operator()(glm::vec<4, T, Q> const& v) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::vec<4, T, Q> >::operator()(glm::vec<4, T, Q> const& v) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<T> hasher;
@ -53,7 +53,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::qua<T, Q>>::operator()(glm::qua<T,Q> const& q) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::qua<T, Q> >::operator()(glm::qua<T,Q> const& q) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<T> hasher;
@ -65,7 +65,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::tdualquat<T, Q>>::operator()(glm::tdualquat<T, Q> const& q) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::tdualquat<T, Q> >::operator()(glm::tdualquat<T, Q> const& q) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::qua<T, Q>> hasher;
@ -75,7 +75,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 2, T, Q>>::operator()(glm::mat<2, 2, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 2, T, Q> >::operator()(glm::mat<2, 2, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<2, T, Q>> hasher;
@ -85,7 +85,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 3, T, Q>>::operator()(glm::mat<2, 3, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 3, T, Q> >::operator()(glm::mat<2, 3, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<3, T, Q>> hasher;
@ -95,7 +95,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 4, T, Q>>::operator()(glm::mat<2, 4, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<2, 4, T, Q> >::operator()(glm::mat<2, 4, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<4, T, Q>> hasher;
@ -105,7 +105,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 2, T, Q>>::operator()(glm::mat<3, 2, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 2, T, Q> >::operator()(glm::mat<3, 2, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<2, T, Q>> hasher;
@ -116,7 +116,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 3, T, Q>>::operator()(glm::mat<3, 3, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 3, T, Q> >::operator()(glm::mat<3, 3, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<3, T, Q>> hasher;
@ -127,7 +127,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 4, T, Q>>::operator()(glm::mat<3, 4, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<3, 4, T, Q> >::operator()(glm::mat<3, 4, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<4, T, Q>> hasher;
@ -138,7 +138,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 2, T,Q>>::operator()(glm::mat<4, 2, T,Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 2, T,Q> >::operator()(glm::mat<4, 2, T,Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<2, T, Q>> hasher;
@ -150,7 +150,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 3, T,Q>>::operator()(glm::mat<4, 3, T,Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 3, T,Q> >::operator()(glm::mat<4, 3, T,Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<3, T, Q>> hasher;
@ -162,7 +162,7 @@ namespace std
}
template<typename T, glm::qualifier Q>
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 4, T,Q>>::operator()(glm::mat<4, 4, T, Q> const& m) const GLM_NOEXCEPT
GLM_FUNC_QUALIFIER size_t hash<glm::mat<4, 4, T,Q> >::operator()(glm::mat<4, 4, T, Q> const& m) const GLM_NOEXCEPT
{
size_t seed = 0;
hash<glm::vec<4, T, Q>> hasher;

12
glm/gtx/matrix_decompose.inl
View File

@ -209,20 +209,20 @@ namespace detail
m *= glm::translate(translation);
m *= glm::mat4_cast(orientation);
if (skew.x) {
glm::mat4 tmp { 1.f };
if (abs(skew.x) > static_cast<T>(0)) {
glm::mat4 tmp(1.f);
tmp[2][1] = skew.x;
m *= tmp;
}
if (skew.y) {
glm::mat4 tmp { 1.f };
if (abs(skew.y) > static_cast<T>(0)) {
glm::mat4 tmp(1.f);
tmp[2][0] = skew.y;
m *= tmp;
}
if (skew.z) {
glm::mat4 tmp { 1.f };
if (abs(skew.z) > static_cast<T>(0)) {
glm::mat4 tmp(1.f);
tmp[1][0] = skew.z;
m *= tmp;
}

2
glm/gtx/string_cast.inl
View File

@ -31,7 +31,7 @@ namespace detail
# if (GLM_COMPILER & GLM_COMPILER_VC)
vsprintf_s(text, STRING_BUFFER, msg, list);
# else//
std::vsprintf(text, msg, list);
std::vsnprintf(text, STRING_BUFFER, msg, list);
# endif//
va_end(list);

2
test/CMakeLists.txt
View File

@ -11,7 +11,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
if(GLM_TEST_ENABLE_CXX_20)
set(CMAKE_CXX_STANDARD 20)
add_definitions(-DGLM_FORCE_CXX2A)
add_definitions(-DGLM_FORCE_CXX20)
if(NOT GLM_QUIET)
message(STATUS "GLM: Build with C++20 features")
endif()

18
test/ext/ext_matrix_common.cpp
View File

@ -70,7 +70,7 @@ static int test_abs()
glm::bvec4 const col2 = glm::equal(D[1], A[1]);
glm::bvec4 const col3 = glm::equal(D[2], A[2]);
glm::bvec4 const col4 = glm::equal(D[3], A[3]);
Error += glm::all(glm::bvec4{glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4)}) ? 0 : 1;
Error += glm::all(glm::bvec4(glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4))) ? 0 : 1;
}
{
glm::mat4x3 A(
@ -91,7 +91,7 @@ static int test_abs()
glm::bvec3 const col2 = glm::equal(D[1], A[1]);
glm::bvec3 const col3 = glm::equal(D[2], A[2]);
glm::bvec3 const col4 = glm::equal(D[3], A[3]);
Error += glm::all(glm::bvec4{glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4)}) ? 0 : 1;
Error += glm::all(glm::bvec4(glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4))) ? 0 : 1;
}
{
glm::mat4x2 A(
@ -112,7 +112,7 @@ static int test_abs()
glm::bvec2 const col2 = glm::equal(D[1], A[1]);
glm::bvec2 const col3 = glm::equal(D[2], A[2]);
glm::bvec2 const col4 = glm::equal(D[3], A[3]);
Error += glm::all(glm::bvec4{glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4)}) ? 0 : 1;
Error += glm::all(glm::bvec4(glm::all(col1), glm::all(col2), glm::all(col3), glm::all(col4))) ? 0 : 1;
}
// -------------------- //
@ -134,7 +134,7 @@ static int test_abs()
glm::bvec4 const col1 = glm::equal(D[0], A[0]);
glm::bvec4 const col2 = glm::equal(D[1], A[1]);
glm::bvec4 const col3 = glm::equal(D[2], A[2]);
Error += glm::all(glm::bvec3{glm::all(col1), glm::all(col2), glm::all(col3)}) ? 0 : 1;
Error += glm::all(glm::bvec3(glm::all(col1), glm::all(col2), glm::all(col3))) ? 0 : 1;
}
{
glm::mat3 A(
@ -152,7 +152,7 @@ static int test_abs()
glm::bvec3 const col1 = glm::equal(D[0], A[0]);
glm::bvec3 const col2 = glm::equal(D[1], A[1]);
glm::bvec3 const col3 = glm::equal(D[2], A[2]);
Error += glm::all(glm::bvec3{glm::all(col1), glm::all(col2), glm::all(col3)}) ? 0 : 1;
Error += glm::all(glm::bvec3(glm::all(col1), glm::all(col2), glm::all(col3))) ? 0 : 1;
}
{
glm::mat3x2 A(
@ -170,7 +170,7 @@ static int test_abs()
glm::bvec2 const col1 = glm::equal(D[0], A[0]);
glm::bvec2 const col2 = glm::equal(D[1], A[1]);
glm::bvec2 const col3 = glm::equal(D[2], A[2]);
Error += glm::all(glm::bvec3{glm::all(col1), glm::all(col2), glm::all(col3)}) ? 0 : 1;
Error += glm::all(glm::bvec3(glm::all(col1), glm::all(col2), glm::all(col3))) ? 0 : 1;
}
// -------------------- //
@ -189,7 +189,7 @@ static int test_abs()
glm::mat2x4 D = glm::abs(C);
glm::bvec4 const col1 = glm::equal(D[0], A[0]);
glm::bvec4 const col2 = glm::equal(D[1], A[1]);
Error += glm::all(glm::bvec2{glm::all(col1), glm::all(col2)}) ? 0 : 1;
Error += glm::all(glm::bvec2(glm::all(col1), glm::all(col2))) ? 0 : 1;
}
{
glm::mat2x3 A(
@ -204,7 +204,7 @@ static int test_abs()
glm::mat2x3 D = glm::abs(C);
glm::bvec3 const col1 = glm::equal(D[0], A[0]);
glm::bvec3 const col2 = glm::equal(D[1], A[1]);
Error += glm::all(glm::bvec2{glm::all(col1), glm::all(col2)}) ? 0 : 1;
Error += glm::all(glm::bvec2(glm::all(col1), glm::all(col2))) ? 0 : 1;
}
{
glm::mat2 A(
@ -219,7 +219,7 @@ static int test_abs()
glm::mat2 D = glm::abs(C);
glm::bvec2 const col1 = glm::equal(D[0], A[0]);
glm::bvec2 const col2 = glm::equal(D[1], A[1]);
Error += glm::all(glm::bvec2{glm::all(col1), glm::all(col2)}) ? 0 : 1;
Error += glm::all(glm::bvec2(glm::all(col1), glm::all(col2))) ? 0 : 1;
}
return Error;

13
test/gtx/gtx_hash.cpp
View File

@ -1,5 +1,7 @@
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/hash.hpp>
#if defined(GLM_GTX_hash) && GLM_LANG & GLM_LANG_CXX11
#include <unordered_map>
int test_compile()
@ -42,15 +44,18 @@ int test_compile()
std::unordered_map<glm::mat4x4, int> map_mat4x4;
Error += ++map_mat4x4[glm::mat4x4(0.0f)];
return Error > 0 ? 0 : 1;
return Error > 0 ? 0 : 1;
}
#endif//GLM_LANG& GLM_LANG_CXX11
int main()
{
int Error = 0;
int Error = 0;
Error += test_compile();
#if defined(GLM_GTX_hash)
Error += test_compile();
#endif//
return Error;
return Error;
}