common.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
 
#ifndef FENNEC_MATH_COMMON_H
#define FENNEC_MATH_COMMON_H
 
 
 
#include <fennec/math/detail/_math.h>
 
#include <fennec/lang/limits.h>
 
#include <fennec/math/vector.h>
 
#if FENNEC_COMPILER_MSVC
#define isnanf(x) isnan(x)
#define isinff(x) isinf(x)
#endif
 
namespace fennec
{
 
 
// Sign Functions ======================================================================================================
 
 
 
 
 
// Sign ================================================================================================================
 
template<typename genType>
constexpr genType sign(genType x) {
    return (x < genType(0) ? genType(-1) : genType(1)) * static_cast<genType>(x != 0); // reduces to cmove
}
 
 
// Absolute Value ======================================================================================================
 
template<typename genType>
constexpr genType abs(genType x) {
    return x * fennec::sign(x);
}
 
 
 
 
// Rounding Functions ==================================================================================================
 
 
 
 
// Floor ===============================================================================================================
 
template<typename genType>
constexpr genType floor(genType x) {
    return ::floor(x);
}
 
 
 
// Ceil ================================================================================================================
 
template<typename genType>
constexpr genType ceil(genType x) {
    return ::ceil(x);
}
 
 
 
// Round ===============================================================================================================
 
template<typename genType> constexpr genType round(genType x) {
    return ::round(x);
}
 
 
 
// Trunc ===============================================================================================================
 
template<typename genType>
constexpr genType trunc(genType x) {
    return ::trunc(x);
}
 
 
 
// Round Even ==========================================================================================================
 
template<typename genType>
constexpr genType roundEven(genType x) {
    static const genType e = numeric_limits<genType>::epsilon();
    int I = static_cast<int>(x);
    genType i = static_cast<genType>(I);
    genType f = x - i;
    if (abs(f - genType(0.5)) > e)
        return fennec::round(x);
 
    bool dir = (I % 2);
    return dir ? i + 1 : i;
 
    // Older version that generates significantly more branching and asm instructions
    //const genType e = numeric_limits<genType>::epsilon();
    //genType f = x - fennec::floor(x);
    //if (fennec::abs(f - genType(0.5)) > e)
    //  return fennec::round(x);
    //
    //genType i = fennec::floor(x);
    //genType r = i / 2;
    //bool up = r - fennec::floor(r) > e; // This will cause a branch in most circumstances
    //return i + static_cast<genType>(up);
}
 
 
 
// Floating Point Functions ============================================================================================
 
 
 
 
// Fract ===============================================================================================================
 
template<typename genType>
constexpr genType fract(genType x) {
    return x - ::floor(x);
}
 
 
// Mod =================================================================================================================
 
template<typename genType>
constexpr genType mod(genType x, genType y) {
    return x - y * fennec::floor(x / y);
}
 
 
// ModF ================================================================================================================
 
template<typename genType>
constexpr genType modf(genType x, genType& i) {
    i = fennec::floor(x); return fennec::fract(x);
}
 
 
// Is NaN ==============================================================================================================
 
template<typename genType, typename genBType = bool_t> requires(is_bool_v<genBType>)
constexpr genBType isnan(genType x) {
    return ::isnanf(x);
}
 
 
// Is Inf ==============================================================================================================
 
template<typename genType, typename genBType = bool_t> requires(is_bool_v<genBType>)
constexpr genBType isinf(genType x) {
    return ::isinff(x);
}
 
 
 
// Bit Conversion ======================================================================================================
 
template<typename genType, typename genIType = int_t> requires(is_floating_point_v<genType> and is_integral_v<genIType> and is_signed_v<genIType> and sizeof(genType) == sizeof(genIType))
constexpr genIType floatBitsToInt(genType x) {
    return fennec::bit_cast<genIType>(x);
}
 
 
template<typename genType, typename genUType = uint_t> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
constexpr genUType floatBitsToUint(genType x) {
    return fennec::bit_cast<genUType>(x);
}
 
 
template<typename genType = float_t, typename genIType = int_t> requires(is_floating_point_v<genType> and is_integral_v<genIType> and is_signed_v<genIType> and sizeof(genType) == sizeof(genIType))
constexpr genType intBitsToFloat(genIType x) {
    return fennec::bit_cast<genType>(x);
}
 
 
template<typename genType = float_t, typename genUType = uint_t> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
constexpr genType uintBitsToFloat(genUType x) {
    return fennec::bit_cast<genType>(x);
}
 
 
 
// fma =================================================================================================================
 
template<typename genType>
constexpr genType fma(genType a, genType b, genType c) {
    return genType(::fma(a, b, c));
}
 
 
 
// frexp ===============================================================================================================
 
template<typename genType, typename genIType = int_t> requires(is_integral_v<genIType>)
constexpr genType frexp(genType x, genIType& exp) {
    return ::frexp(x, &exp);
}
 
 
 
// ldexp ===============================================================================================================
 
template<typename genType, typename genIType = int_t> requires(is_integral_v<genIType>)
constexpr genType ldexp(genType x, genIType exp) {
    return ::ldexp(x, exp);
}
 
 
 
 
// Comparison Functions ================================================================================================
 
 
 
 
// Min =================================================================================================================
 
template<typename genType>
constexpr genType min(genType x, genType y) {
    return (y < x) ? y : x;
}
 
 
// Max =================================================================================================================
 
template<typename genType>
constexpr genType max(genType x, genType y) {
    return (x < y) ? y : x;
}
 
 
// Clamp ===============================================================================================================
 
template<typename genType>
constexpr genType clamp(genType x, genType minVal, genType maxVal) {
    return min(max(x, minVal), maxVal);
}
 
 
 
 
// Curves ==============================================================================================================
 
 
 
 
// Step ================================================================================================================
 
template<typename genType> requires(is_floating_point_v<genType>)
constexpr genType step(genType edge, genType x) {
    return static_cast<genType>(not(x < edge));
}
 
 
// Smoothstep ==========================================================================================================
 
template<typename genType> requires(is_floating_point_v<genType>)
constexpr genType smoothstep(genType edge0, genType edge1, genType x) {
    genType t = fennec::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f); return t * t * (3 - 2 * t);
}
 
 
// Mix =================================================================================================================
 
template<typename genType> requires(is_floating_point_v<genType>)
constexpr genType mix(genType x, genType y, genType a) {
    return x * (genType(1.0) - a) + y * a;
}
 
 
// Mix (Bool) ==========================================================================================================
 
template<typename genType, typename genBType = bool_t> requires(is_bool_v<genBType> and is_floating_point_v<genType>)
constexpr genType mix(genType x, genType y, genBType a) {
    return a ? y : x;
}
 
 
// Internal ============================================================================================================
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> sign(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::sign(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> abs(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::abs(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> floor(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::floor(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> ceil(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::ceil(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> round(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::round(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> trunc(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::trunc(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> roundEven(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::roundEven(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> fract(const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::fract(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> mod(const vector<genType, i...>& x, genType y) {
    return x - y * fennec::floor(x / y);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> mod(const vector<genType, i...>& x, const vector<genType, i...>& y) {
    return x - y * fennec::floor(x / y);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> modf(const vector<genType, i...>& x, vector<genType, i...>& I) {
    I = fennec::floor(x); return fennec::fract(x);
}
 
template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
constexpr vector<genBType, i...> isnan(const vector<genType, i...>& x) {
    return vector<genBType, i...>(fennec::isnan(x[i]) ...);
}
 
template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
constexpr vector<genBType, i...> isinf(const vector<genType, i...>& x) {
    return vector<genBType, i...>(fennec::isinf(x[i]) ...);
}
 
template<typename genType = float_t, typename genIType = int_t, size_t...i> requires(is_floating_point_v<genType> and is_integral_v<genIType> and is_signed_v<genIType> and sizeof(genType) == sizeof(genIType))
constexpr vector<genIType, i...> floatBitsToInt(const vector<genType, i...>& x) {
    return vector<genIType, i...>(fennec::bit_cast<genIType>(x[i])...);
}
 
template<typename genType = float_t, typename genUType = uint_t, size_t...i> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
constexpr vector<genUType, i...> floatBitsToUint(const vector<genType, i...>& x) {
    return vector<genUType, i...>(fennec::bit_cast<genUType>(x[i])...);
}
 
template<typename genType = float_t, typename genIType = int_t, size_t...i> requires(is_floating_point_v<genType> and is_integral_v<genIType> and is_signed_v<genIType> and sizeof(genType) == sizeof(genIType))
constexpr vector<genType, i...> intBitsToFloat(const vector<genIType, i...>& x) {
    return vector<genType, i...>(fennec::bit_cast<genType>(x[i]) ...);
}
 
template<typename genType = float_t, typename genUType = uint_t, size_t...i> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
constexpr vector<genType, i...> uintBitsToFloat(const vector<genUType, i...>& x) {
    return vector<genType, i...>(fennec::bit_cast<genType>(x[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> fma(const vector<genType, i...>& a, const vector<genType, i...>& b, const vector<genType, i...>& c) {
    return vector<genType, i...>(fennec::fma(a[i], b[i], c[i]) ...);
}
 
template<typename genType, typename genIType = int_t, size_t...i> requires(is_integral_v<genIType>)
constexpr vector<genType, i...> frexp(const vector<genType, i...>& x, vector<genIType, i...>& exp) {
    return vector<genType, i...>(fennec::frexp(x[i], exp[i])...);
}
 
template<typename genType, typename genIType = int_t, size_t...i> requires(is_integral_v<genIType>)
constexpr vector<genType, i...> ldexp(const vector<genType, i...>& x, const vector<genIType, i...>& exp) {
    return vector<genType, i...>(fennec::ldexp(x[i], exp[i])...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> min(genType x, const vector<genType, i...>& y) {
    return vector<genType, i...>(fennec::min(x, y[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> min(const vector<genType, i...>& x, genType y) {
    return vector<genType, i...>(fennec::min(x[i], y) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> min(const vector<genType, i...>& x, const vector<genType, i...>& y) {
    return vector<genType, i...>(fennec::min(x[i], y[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> max(genType x, const vector<genType, i...>& y) {
    return vector<genType, i...>(fennec::max(x, y[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> max(const vector<genType, i...>& x, genType y) {
    return vector<genType, i...>(fennec::max(x[i], y) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> max(const vector<genType, i...>& x, const vector<genType, i...>& y) {
    return vector<genType, i...>(fennec::max(x[i], y[i]) ...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, genType minVal, genType maxVal) {
    return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal), maxVal)...);
}
 
template<typename genType, size_t...i>
constexpr vector<genType, i...> clamp(const vector<genType, i...>& x, const vector<genType, i...>& minVal, const vector<genType, i...>& maxVal) {
    return vector<genType, i...>(fennec::min(fennec::max(x[i], minVal[i]), maxVal[i])...);
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> step(genType edge, const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::step(edge, x[i]) ...);
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> step(const vector<genType, i...>& edge, const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::step(edge[i], x[i]) ...);
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> smoothstep(genType edge0, genType edge1, const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::smoothstep(edge0,    edge1,    x[i]) ...);
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> smoothstep(const vector<genType, i...>& edge0, const vector<genType, i...>& edge1, const vector<genType, i...>& x) {
    return vector<genType, i...>(fennec::smoothstep(edge0[i], edge1[i], x[i]) ...);
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, genType a) {
    return x * (genType(1.0) - a) + y * a;
}
 
template<typename genType, size_t...i> requires(is_floating_point_v<genType>)
constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, const vector<genType, i...>& a) {
    return x * (genType(1.0) - a) + y * a;
}
 
template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_floating_point_v<genType>)
constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, genBType a) {
    return genDType((a ? y[i] : x[i])...);
}
 
 
template<typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType>)
constexpr vector<genBType, i...> mix(const vector<genBType, i...>& x, const vector<genBType, i...>& y, const vector<genBType, i...>& a) {
    return genBType((a[i] ? y[i] : x[i])...);
}
 
template<typename genType, typename genBType = bool_t, size_t...i> requires(is_bool_v<genBType> and is_floating_point_v<genType>)
constexpr vector<genType, i...> mix(const vector<genType, i...>& x, const vector<genType, i...>& y, const vector<genBType, i...>& a) {
    return genDType((a[i] ? y[i] : x[i])...);
}
 
 
 
 
}
 
#endif // FENNEC_MATH_COMMON_H