Skip to content

Commit

Permalink
[FIX] : fix duplicate template issue for vec4<float>
Browse files Browse the repository at this point in the history
  • Loading branch information
@aiekick
aiekick committed Apr 21, 2024
1 parent d8a0fa9 commit f070ca0
Show file tree
Hide file tree
Showing 2 changed files with 135 additions and 145 deletions.
144 changes: 132 additions & 12 deletions include/ctools/cTools.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -337,9 +337,9 @@ bool CTOOLS_API isbitset(int32_t vContainer, int32_t vBit);
// is this bit/bit_group is set and only this one
bool CTOOLS_API isbitset_exclusive(int32_t vContainer, int32_t vBit);
// set this bit/bit_group to 1
void CTOOLS_API setbit(int32_t vContainer, int32_t vBit);
void CTOOLS_API setbit(int32_t& vContainer, int32_t vBit);
// set this bit/bit_group to 0
void CTOOLS_API unsetbit(int32_t vContainer, int32_t vBit);
void CTOOLS_API unsetbit(int32_t& vContainer, int32_t vBit);

/////////////////////////////////////////////////////////////
///////// splitStringToVector ///////////////////////////////
Expand Down Expand Up @@ -2102,16 +2102,6 @@ inline bool valid(const fvec4& a) {
return floatIsValid(a.x) && floatIsValid(a.y) && floatIsValid(a.z) && floatIsValid(a.w);
}

// specialization for fvec4
/*template <>
inline bool operator==(fvec4 v, fvec4 f) {
return IS_FLOAT_EQUAL(f.x, v.x) && IS_FLOAT_EQUAL(f.y, v.y) && IS_FLOAT_EQUAL(f.z, v.z) && IS_FLOAT_EQUAL(f.w, v.w);
}
template <>
inline bool operator!=(fvec4 v, fvec4 f) {
return IS_FLOAT_DIFFERENT(f.x, v.x) || IS_FLOAT_DIFFERENT(f.y, v.y) || IS_FLOAT_DIFFERENT(f.z, v.z) || IS_FLOAT_DIFFERENT(f.w, v.w);
}*/

/////////////////////////////////////////////////////////////////////////
template <typename T>
struct rect // bottom left to top right
Expand Down Expand Up @@ -3167,6 +3157,136 @@ typedef variant<double> dvariant; // utile pour le type de renvoi des vec2,3,4
typedef variant<size_t> uvariant;
typedef variant<int> ivariant;

/////////////////////////////////////////////////////////////
///////// SPECIALIZATION // VEC2 / VEC3 / VEC4 / QUAT ///////
/////////////////////////////////////////////////////////////

template <>
inline bool ct::vec2<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a));
}
template <>
inline bool ct::vec2<float>::operator==(const ct::vec2<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y));
}
template <>
inline bool ct::vec2<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a));
}
template <>
inline bool ct::vec2<float>::operator!=(const ct::vec2<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y));
}

template <>
inline bool ct::vec2<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a));
}
template <>
inline bool ct::vec2<double>::operator==(const ct::vec2<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y));
}
template <>
inline bool ct::vec2<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a));
}
template <>
inline bool ct::vec2<double>::operator!=(const ct::vec2<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y));
}

template <>
inline bool ct::vec3<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a) && IS_FLOAT_EQUAL(z, a));
}
template <>
inline bool ct::vec3<float>::operator==(const ct::vec3<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y) && IS_FLOAT_EQUAL(z, v.z));
}
template <>
inline bool ct::vec3<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a) || IS_FLOAT_DIFFERENT(z, a));
}
template <>
inline bool ct::vec3<float>::operator!=(const ct::vec3<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y) || IS_FLOAT_DIFFERENT(z, v.z));
}

template <>
inline bool ct::vec3<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a) && IS_DOUBLE_EQUAL(z, a));
}
template <>
inline bool ct::vec3<double>::operator==(const ct::vec3<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y) && IS_DOUBLE_EQUAL(z, v.z));
}
template <>
inline bool ct::vec3<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a) || IS_DOUBLE_DIFFERENT(z, a));
}
template <>
inline bool ct::vec3<double>::operator!=(const ct::vec3<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y) || IS_DOUBLE_DIFFERENT(z, v.z));
}

template <>
inline bool ct::vec4<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a) && IS_FLOAT_EQUAL(z, a) && IS_FLOAT_EQUAL(w, a));
}
template <>
inline bool ct::vec4<float>::operator==(const ct::vec4<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y) && IS_FLOAT_EQUAL(z, v.z) && IS_FLOAT_EQUAL(w, v.w));
}
template <>
inline bool ct::vec4<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a) || IS_FLOAT_DIFFERENT(z, a) || IS_FLOAT_DIFFERENT(w, a));
}
template <>
inline bool ct::vec4<float>::operator!=(const ct::vec4<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y) || IS_FLOAT_DIFFERENT(z, v.z) || IS_FLOAT_DIFFERENT(w, v.w));
}

template <>
inline bool ct::vec4<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a) && IS_DOUBLE_EQUAL(z, a) && IS_DOUBLE_EQUAL(w, a));
}
template <>
inline bool ct::vec4<double>::operator==(const ct::vec4<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y) && IS_DOUBLE_EQUAL(z, v.z) && IS_DOUBLE_EQUAL(w, v.w));
}
template <>
inline bool ct::vec4<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a) || IS_DOUBLE_DIFFERENT(z, a) || IS_DOUBLE_DIFFERENT(w, a));
}
template <>
inline bool ct::vec4<double>::operator!=(const ct::vec4<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y) || IS_DOUBLE_DIFFERENT(z, v.z) || IS_DOUBLE_DIFFERENT(w, v.w));
}

template <>
inline void ct::quat<float>::normalize() {
float n = sqrt(x * x + y * y + z * z + w * w);
if (IS_FLOAT_EQUAL(n, 0.0f)) {
return;
}
x /= n;
y /= n;
z /= n;
w /= n;
}

template <>
inline void ct::quat<double>::normalize() {
double n = sqrt(x * x + y * y + z * z + w * w);
if (IS_DOUBLE_EQUAL(n, 0.0)) {
return;
}
x /= n;
y /= n;
z /= n;
w /= n;
}

/////////////////////////////////////////////////////////////
///////// GetNewBufferFromList //////////////////////////////
/////////////////////////////////////////////////////////////
Expand Down
136 changes: 3 additions & 133 deletions src/cTools.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -139,12 +139,12 @@ bool ct::isbitset_exclusive(int32_t vContainer, int32_t vBit) {
return ((vContainer & vBit) != vBit);
}

void ct::setbit(int32_t vContainer, int32_t vBit) {
void ct::setbit(int32_t& vContainer, int32_t vBit) {
vContainer |= vBit;
}

void ct::unsetbit(int32_t vContainer, int32_t vBit) {
vContainer = vContainer & ~vBit;
void ct::unsetbit(int32_t& vContainer, int32_t vBit) {
vContainer &= ~vBit;
}

/////////////////////////////////////////////////////////////
Expand Down Expand Up @@ -597,136 +597,6 @@ ::std::string ct::texture::GetString() const {
}
#endif

/////////////////////////////////////////////////////////////
///////// SPECIALIZATION // VEC2 / VEC3 / VEC4 / QUAT ///////
/////////////////////////////////////////////////////////////

template <>
bool ct::vec2<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a));
}
template <>
bool ct::vec2<float>::operator==(const ct::vec2<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y));
}
template <>
bool ct::vec2<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a));
}
template <>
bool ct::vec2<float>::operator!=(const ct::vec2<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y));
}

template <>
bool ct::vec2<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a));
}
template <>
bool ct::vec2<double>::operator==(const ct::vec2<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y));
}
template <>
bool ct::vec2<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a));
}
template <>
bool ct::vec2<double>::operator!=(const ct::vec2<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y));
}

template <>
bool ct::vec3<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a) && IS_FLOAT_EQUAL(z, a));
}
template <>
bool ct::vec3<float>::operator==(const ct::vec3<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y) && IS_FLOAT_EQUAL(z, v.z));
}
template <>
bool ct::vec3<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a) || IS_FLOAT_DIFFERENT(z, a));
}
template <>
bool ct::vec3<float>::operator!=(const ct::vec3<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y) || IS_FLOAT_DIFFERENT(z, v.z));
}

template <>
bool ct::vec3<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a) && IS_DOUBLE_EQUAL(z, a));
}
template <>
bool ct::vec3<double>::operator==(const ct::vec3<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y) && IS_DOUBLE_EQUAL(z, v.z));
}
template <>
bool ct::vec3<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a) || IS_DOUBLE_DIFFERENT(z, a));
}
template <>
bool ct::vec3<double>::operator!=(const ct::vec3<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y) || IS_DOUBLE_DIFFERENT(z, v.z));
}

template <>
bool ct::vec4<float>::operator==(const float& a) {
return (IS_FLOAT_EQUAL(x, a) && IS_FLOAT_EQUAL(y, a) && IS_FLOAT_EQUAL(z, a) && IS_FLOAT_EQUAL(w, a));
}
template <>
bool ct::vec4<float>::operator==(const ct::vec4<float>& v) {
return (IS_FLOAT_EQUAL(x, v.x) && IS_FLOAT_EQUAL(y, v.y) && IS_FLOAT_EQUAL(z, v.z) && IS_FLOAT_EQUAL(w, v.w));
}
template <>
bool ct::vec4<float>::operator!=(const float& a) {
return (IS_FLOAT_DIFFERENT(x, a) || IS_FLOAT_DIFFERENT(y, a) || IS_FLOAT_DIFFERENT(z, a) || IS_FLOAT_DIFFERENT(w, a));
}
template <>
bool ct::vec4<float>::operator!=(const ct::vec4<float>& v) {
return (IS_FLOAT_DIFFERENT(x, v.x) || IS_FLOAT_DIFFERENT(y, v.y) || IS_FLOAT_DIFFERENT(z, v.z) || IS_FLOAT_DIFFERENT(w, v.w));
}

template <>
bool ct::vec4<double>::operator==(const double& a) {
return (IS_DOUBLE_EQUAL(x, a) && IS_DOUBLE_EQUAL(y, a) && IS_DOUBLE_EQUAL(z, a) && IS_DOUBLE_EQUAL(w, a));
}
template <>
bool ct::vec4<double>::operator==(const ct::vec4<double>& v) {
return (IS_DOUBLE_EQUAL(x, v.x) && IS_DOUBLE_EQUAL(y, v.y) && IS_DOUBLE_EQUAL(z, v.z) && IS_DOUBLE_EQUAL(w, v.w));
}
template <>
bool ct::vec4<double>::operator!=(const double& a) {
return (IS_DOUBLE_DIFFERENT(x, a) || IS_DOUBLE_DIFFERENT(y, a) || IS_DOUBLE_DIFFERENT(z, a) || IS_DOUBLE_DIFFERENT(w, a));
}
template <>
bool ct::vec4<double>::operator!=(const ct::vec4<double>& v) {
return (IS_DOUBLE_DIFFERENT(x, v.x) || IS_DOUBLE_DIFFERENT(y, v.y) || IS_DOUBLE_DIFFERENT(z, v.z) || IS_DOUBLE_DIFFERENT(w, v.w));
}

template <>
void ct::quat<float>::normalize() {
float n = sqrt(x * x + y * y + z * z + w * w);
if (IS_FLOAT_EQUAL(n, 0.0f)) {
return;
}
x /= n;
y /= n;
z /= n;
w /= n;
}

template <>
void ct::quat<double>::normalize() {
double n = sqrt(x * x + y * y + z * z + w * w);
if (IS_DOUBLE_EQUAL(n, 0.0)) {
return;
}
x /= n;
y /= n;
z /= n;
w /= n;
}

/////////////////////////////////////////////////////////////
///////// BUFFERS ///////////////////////////////////////////
/////////////////////////////////////////////////////////////
Expand Down

0 comments on commit f070ca0

Please sign in to comment.