Skip to content

Reuse code to remove overloads via templates #1319

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 12 commits into
base: master
Choose a base branch
from
Open

Reuse code to remove overloads via templates #1319

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
5ada231
Remove overloads in `value_ptr`
ZXShady Mar 7, 2025
eae3903
Remove overloads of functions in noise.hpp
ZXShady Mar 7, 2025
302ea03
Remove overloads in `extend`,`min_max`
ZXShady Mar 7, 2025
56b40af
Remove `type_trait.inl` infavor of using `enums` for constants.
ZXShady Mar 7, 2025
d38a61f
Use overloading instead of template specilizations
ZXShady Mar 7, 2025
8afe61e
Remove one member structs in `vec_swizzle`
ZXShady Mar 9, 2025
a81871a
Add simple test for `vec_swizzle`
ZXShady Mar 14, 2025
a04b1af
Remove unneccesary `vec_swizzle` overloads and added a script to gene…
ZXShady Mar 7, 2025
de92b8f
Remove overloads in `glm::hash` and specilize correctly
ZXShady Mar 14, 2025
b845c29
Reuse operators to implement other operators for `glm::mat`
ZXShady Mar 14, 2025
5a27826
Reuse operators to implement other operators for `glm::vec`
ZXShady Mar 14, 2025
63d8733
Use comparisons instead of template specilizatins
ZXShady Mar 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
47 changes: 6 additions & 41 deletions glm/detail/_noise.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,20 +17,8 @@ namespace detail
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
template<length_t L,typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> permute(vec<L, T, Q> const& x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
Expand All @@ -41,41 +29,18 @@ namespace detail
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
{
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
template<length_t L,typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> taylorInvSqrt(vec<L, T, Q> const& r)
{
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
{
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
template<length_t L,typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fade(vec<L, T, Q> const& t)
{
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
{
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}

template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
{
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}
}//namespace detail
}//namespace glm

962 changes: 481 additions & 481 deletions glm/detail/_swizzle.hpp
View file
Open in desktop

Large diffs are not rendered by default.

1 change: 0 additions & 1 deletion glm/detail/func_common.inl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,6 @@ namespace glm
};

// abs
template<>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x)
{
int const y = x >> (sizeof(int) * 8 - 1);
Expand Down
2 changes: 0 additions & 2 deletions glm/detail/func_integer_simd.inl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -45,14 +45,12 @@ namespace detail
}//namespace detail

# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<>
GLM_FUNC_QUALIFIER int bitCount(uint x)
{
return _mm_popcnt_u32(x);
}

# if(GLM_MODEL == GLM_MODEL_64)
template<>
GLM_FUNC_QUALIFIER int bitCount(detail::uint64 x)
{
return static_cast<int>(_mm_popcnt_u64(x));
Expand Down
54 changes: 54 additions & 0 deletions glm/detail/mat2xR_common_operators.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,54 @@

#pragma once
#include "qualifier.hpp"
#include "mat_common_operators.hpp"
namespace glm {


template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q> operator-(mat<2,R,T,Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q>& operator++(mat<2,R,T,Q>& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q>& operator--(mat<2,R,T,Q>& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q> operator+(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2);
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q>& operator+=(mat<2,R,T,Q>& m1, mat<2,R,U,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q> operator-(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2);
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R,T,Q>& operator-=(mat<2,R,T,Q>& m1, mat<2,R,U,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator+(mat<2,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator+(T scalar,mat<2,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator-(mat<2,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator-(T scalar,mat<2,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator*(mat<2,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator*(T scalar,mat<2,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator/(mat<2,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<2,R, T, Q> operator/(T scalar,mat<2,R, T, Q> const& m);

}
#ifndef GLM_EXTERNAL_TEMPLATE
#include "mat2xR_common_operators.inl"
#endif

112 changes: 112 additions & 0 deletions glm/detail/mat2xR_common_operators.inl
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,112 @@

namespace glm {


template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q> operator-(mat<2,R,T,Q> const& m) {
return mat<2,R,T,Q>(-m[0],-m[1]);
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator++(mat<2,R,T,Q>& m) {
++m[0];
++m[1];
return m;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator--(mat<2,R,T,Q>& m) {
--m[0];
--m[1];
return m;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2) {
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q> operator+(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2) {
return mat<2,R,T,Q>(m1[0] + m2[0],m1[1] + m2[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator+=(mat<2,R,T,Q>& m1, mat<2,R,U,Q> const& m2) {
m1[0] += m2[0];
m1[1] += m2[1];
return m1;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q> operator-(mat<2,R,T,Q> const& m1, mat<2,R,T,Q> const& m2) {
return mat<2,R,T,Q>(m1[0] - m2[0],m1[1] - m2[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator-=(mat<2,R,T,Q>& m1, mat<2,R,U,Q> const& m2) {
m1[0] -= m2[0];
m1[1] -= m2[1];
return m1;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator+(mat<2,R, T, Q> const& m, T scalar) {
return mat<2,R,T,Q>(m[0] + scalar,m[1] + scalar);
}
template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator+(T scalar,mat<2,R, T, Q> const& m) {
return mat<2,R,T,Q>(scalar + m[0],scalar + m[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator+=(mat<2,R,T,Q>& m, U scalar) {
m[0] += scalar;
m[1] += scalar;
return m;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator-(mat<2,R, T, Q> const& m, T scalar) {
return mat<2,R,T,Q>(m[0] - scalar,m[1] - scalar);
}
template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator-(T scalar,mat<2,R, T, Q> const& m) {
return mat<2,R,T,Q>(scalar - m[0],scalar - m[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator-=(mat<2,R,T,Q>& m, U scalar) {
m[0] -= scalar;
m[1] -= scalar;
return m;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator*(mat<2,R, T, Q> const& m, T scalar) {
return mat<2,R,T,Q>(m[0] * scalar,m[1] * scalar);
}
template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator*(T scalar,mat<2,R, T, Q> const& m) {
return mat<2,R,T,Q>(scalar * m[0],scalar * m[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator*=(mat<2,R,T,Q>& m, U scalar) {
m[0] *= scalar;
m[1] *= scalar;
return m;
}

template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator/(mat<2,R, T, Q> const& m, T scalar) {
return mat<2,R,T,Q>(m[0] / scalar,m[1] / scalar);
}
template<length_t R, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R, T, Q> operator/(T scalar,mat<2,R, T, Q> const& m) {
return mat<2,R,T,Q>(scalar / m[0],scalar / m[1]);
}
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2,R,T,Q>& operator/=(mat<2,R,T,Q>& m, U scalar) {
m[0] /= scalar;
m[1] /= scalar;
return m;
}

}

54 changes: 54 additions & 0 deletions glm/detail/mat3xR_common_operators.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,54 @@

#pragma once
#include "qualifier.hpp"
#include "mat_common_operators.hpp"
namespace glm {


template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q> operator-(mat<3,R,T,Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q>& operator++(mat<3,R,T,Q>& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q>& operator--(mat<3,R,T,Q>& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(mat<3,R,T,Q> const& m1, mat<3,R,T,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q> operator+(mat<3,R,T,Q> const& m1, mat<3,R,T,Q> const& m2);
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q>& operator+=(mat<3,R,T,Q>& m1, mat<3,R,U,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q> operator-(mat<3,R,T,Q> const& m1, mat<3,R,T,Q> const& m2);
template<length_t R, typename T, qualifier Q,typename U>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R,T,Q>& operator-=(mat<3,R,T,Q>& m1, mat<3,R,U,Q> const& m2);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator+(mat<3,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator+(T scalar,mat<3,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator-(mat<3,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator-(T scalar,mat<3,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator*(mat<3,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator*(T scalar,mat<3,R, T, Q> const& m);

template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator/(mat<3,R, T, Q> const& m, T scalar);
template<length_t R, typename T, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR mat<3,R, T, Q> operator/(T scalar,mat<3,R, T, Q> const& m);

}
#ifndef GLM_EXTERNAL_TEMPLATE
#include "mat3xR_common_operators.inl"
#endif

Loading