Medusa Slockbower
cf909624df
- Vulkan Configuration Implementations - Fixed build errors on GCC and Clang
298 lines
17 KiB
C++
298 lines
17 KiB
C++
// =====================================================================================================================
|
|
// fennec, a free and open source game engine
|
|
// Copyright © 2025 - 2026 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_METAPROGRAMMING_FLOAT_H
|
|
#define FENNEC_METAPROGRAMMING_FLOAT_H
|
|
|
|
#include <bit>
|
|
#include <iosfwd>
|
|
|
|
inline void float_h()
|
|
{
|
|
std::ofstream out("fennec/lang/float.h");
|
|
|
|
out << "// =====================================================================================================================" << '\n';
|
|
out << "// fennec, a free and open source game engine" << '\n';
|
|
out << "// Copyright © 2025 - 2026 Medusa Slockbower" << '\n';
|
|
out << "//" << '\n';
|
|
out << "// This program is free software: you can redistribute it and/or modify" << '\n';
|
|
out << "// it under the terms of the GNU General Public License as published by" << '\n';
|
|
out << "// the Free Software Foundation, either version 3 of the License, or" << '\n';
|
|
out << "// (at your option) any later version." << '\n';
|
|
out << "//" << '\n';
|
|
out << "// This program is distributed in the hope that it will be useful," << '\n';
|
|
out << "// but WITHOUT ANY WARRANTY; without even the implied warranty of" << '\n';
|
|
out << "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the" << '\n';
|
|
out << "// GNU General Public License for more details." << '\n';
|
|
out << "//" << '\n';
|
|
out << "// You should have received a copy of the GNU General Public License" << '\n';
|
|
out << "// along with this program. If not, see <https://www.gnu.org/licenses/>." << '\n';
|
|
out << "// =====================================================================================================================" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
out << "///" << '\n';
|
|
out << "/// \\file fennec/lang/float.h" << '\n';
|
|
out << "/// \\brief metaprogramming floating point type info" << '\n';
|
|
out << "///" << '\n';
|
|
out << "///" << '\n';
|
|
out << "/// \\details This file is automatically generated for the current build environment." << '\n';
|
|
out << "///" << '\n';
|
|
out << "/// Environment for this build: " FENNEC_LONG_COMPILER_NAME << '\n';
|
|
out << "///" << '\n';
|
|
out << "/// \\copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))" << '\n';
|
|
out << "///" << '\n';
|
|
out << "///" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
out << "#ifndef FENNEC_LANG_FLOAT_H" << '\n';
|
|
out << "#define FENNEC_LANG_FLOAT_H" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
out << "#include <fennec/lang/bits.h>" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
// MAYBE TODO: Generate info without C++ STDLIB to compile natively on platforms without support
|
|
|
|
out << "#undef FLT_HAS_INFINITY" << '\n';
|
|
out << "#undef FLT_HAS_QUIET_NAN" << '\n';
|
|
out << "#undef FLT_HAS_SIGNALING_NAN" << '\n';
|
|
out << "#undef FLT_HAS_DENORM" << '\n';
|
|
out << "#undef FLT_HAS_DENORM_LOSS" << '\n';
|
|
out << "#undef FLT_ROUNDS" << '\n';
|
|
out << "#undef FLT_IS_IEC559" << '\n';
|
|
out << "#undef FLT_MANT_DIG" << '\n';
|
|
out << "#undef FLT_DIG" << '\n';
|
|
out << "#undef FLT_DECIMAL_DIG" << '\n';
|
|
out << "#undef FLT_RADIX" << '\n';
|
|
out << "#undef FLT_MIN_EXP" << '\n';
|
|
out << "#undef FLT_MAX_EXP" << '\n';
|
|
out << "#undef FLT_MIN_10_EXP" << '\n';
|
|
out << "#undef FLT_MAX_10_EXP" << '\n';
|
|
out << "#undef FLT_TRAPS" << '\n';
|
|
out << "#undef FLT_TINYNESS_BEFORE" << '\n';
|
|
out << "#undef FLT_MIN" << '\n';
|
|
out << "#undef FLT_MAX" << '\n';
|
|
out << "#undef FLT_EPSILON" << '\n';
|
|
out << "#undef FLT_INF" << '\n';
|
|
out << "#undef FLT_QUIET_NAN" << '\n';
|
|
out << "#undef FLT_SIGNALING_NAN" << '\n';
|
|
out << "#undef FLT_DENORM_MIN" << '\n';
|
|
out << "#undef FLT_ROUND_ERR" << '\n';
|
|
|
|
|
|
out << "" << '\n';
|
|
|
|
|
|
out << R"(/// \brief Does \emph{float} have an infinity?)" << '\n';
|
|
out << "#define FLT_HAS_INFINITY " << std::dec << std::numeric_limits<float>::has_infinity << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{float} have a quiet NaN?)" << '\n';
|
|
out << "#define FLT_HAS_QUIET_NAN " << std::dec << std::numeric_limits<float>::has_quiet_NaN << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{float} have a signaling NaN?)" << '\n';
|
|
out << "#define FLT_HAS_SIGNALING_NAN " << std::dec << std::numeric_limits<float>::has_signaling_NaN << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{float} use denormalization?)" << '\n';
|
|
out << "#define FLT_HAS_DENORM " << std::dec << std::numeric_limits<float>::has_denorm << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{float} have loss with denormalization?)" << '\n';
|
|
out << "#define FLT_HAS_DENORM_LOSS " << std::dec << std::numeric_limits<float>::has_denorm_loss << '\n';
|
|
|
|
out << R"(/// \brief What rounding style does \emph{float} use?)" << '\n';
|
|
out << "#define FLT_ROUNDS " << std::dec << std::numeric_limits<float>::round_style << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{float} use the IEEE floating point specification?)" << '\n';
|
|
out << "#define FLT_IS_IEC559 " << std::dec << std::numeric_limits<float>::is_iec559 << '\n';
|
|
|
|
out << R"(/// \brief The number of mantissa bits in \emph{float}.)" << '\n';
|
|
out << "#define FLT_MANT_DIG " << std::dec << std::numeric_limits<float>::digits << '\n';
|
|
|
|
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \emph{float} → \emph{text} → \emph{float}.)" << '\n';
|
|
out << "#define FLT_DIG " << std::dec << std::numeric_limits<float>::digits10 << '\n';
|
|
|
|
out << R"(/// \brief The decimal precision required to serialize and deserialize a \emph{float}.)" << '\n';
|
|
out << "#define FLT_DECIMAL_DIG " << std::dec << std::numeric_limits<float>::max_digits10 << '\n';
|
|
|
|
out << R"(/// \brief The radix, or integer base, used to represent a \emph{float}.)" << '\n';
|
|
out << "#define FLT_RADIX " << std::dec << std::numeric_limits<float>::radix << '\n';
|
|
|
|
out << R"(/// \brief The minimum negative integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.)" << '\n';
|
|
out << "#define FLT_MIN_EXP " << std::dec << std::numeric_limits<float>::min_exponent << '\n';
|
|
|
|
out << R"(/// \brief The maximum positive integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.)" << '\n';
|
|
out << "#define FLT_MAX_EXP " << std::dec << std::numeric_limits<float>::max_exponent << '\n';
|
|
|
|
out << R"(/// \brief The minimum negative integer such that \math{{10}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.)" << '\n';
|
|
out << "#define FLT_MIN_10_EXP " << std::dec << std::numeric_limits<float>::min_exponent10 << '\n';
|
|
|
|
out << R"(/// \brief The maximum positive integer such that \math{{10}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.)" << '\n';
|
|
out << "#define FLT_MAX_10_EXP " << std::dec << std::numeric_limits<float>::max_exponent10 << '\n';
|
|
|
|
out << R"(/// \brief Do arithmetics operations with \emph{float} trap?)" << '\n';
|
|
out << "#define FLT_TRAPS " << std::dec << std::numeric_limits<float>::traps << '\n';
|
|
|
|
out << R"(/// \brief Do arithmetics operations with \emph{float} check for underflow?)" << '\n';
|
|
out << "#define FLT_TINYNESS_BEFORE " << std::dec << std::numeric_limits<float>::tinyness_before << '\n';
|
|
|
|
|
|
out << R"(/// \brief Smallest positive, finite, normal value of \emph{float}.)" << '\n';
|
|
out << "#define FLT_MIN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::min() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief Largest positive, finite value of \emph{float}.)" << '\n';
|
|
out << "#define FLT_MAX " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::max() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief The difference between \emph{1.0} and the next representable value of \emph{float}.)" << '\n';
|
|
out << "#define FLT_EPSILON " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::epsilon() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{\inf} of type \emph{float}.)" << '\n';
|
|
out << "#define FLT_INF " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::infinity() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{NaN} of type \emph{float} that does not trap.)" << '\n';
|
|
out << "#define FLT_QUIET_NAN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::quiet_NaN() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{NaN} of type \emph{float} that traps.)" << '\n';
|
|
out << "#define FLT_SIGNALING_NAN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::signaling_NaN()) << ")" << '\n';
|
|
|
|
out << R"(/// \brief Smallest positive, finite, subnormal value of \emph{float}.)" << '\n';
|
|
out << "#define FLT_DENORM_MIN " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::denorm_min() ) << ")" << '\n';
|
|
|
|
out << R"(/// \brief Maximum rounding error of type \emph{float}.)" << '\n';
|
|
out << "#define FLT_ROUND_ERR " << "fennec::bit_cast<float>(0x" << std::hex << std::bit_cast<int>(std::numeric_limits<float>::round_error() ) << ")" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
out << "#undef DBL_HAS_INFINITY" << '\n';
|
|
out << "#undef DBL_HAS_QUIET_NAN" << '\n';
|
|
out << "#undef DBL_HAS_SIGNALING_NAN" << '\n';
|
|
out << "#undef DBL_HAS_DENORM" << '\n';
|
|
out << "#undef DBL_HAS_DENORM_LOSS" << '\n';
|
|
out << "#undef DBL_ROUNDS" << '\n';
|
|
out << "#undef DBL_IS_IEC559" << '\n';
|
|
out << "#undef DBL_MANT_DIG" << '\n';
|
|
out << "#undef DBL_DIG" << '\n';
|
|
out << "#undef DBL_DECIMAL_DIG" << '\n';
|
|
out << "#undef DBL_RADIX" << '\n';
|
|
out << "#undef DBL_MIN_EXP" << '\n';
|
|
out << "#undef DBL_MAX_EXP" << '\n';
|
|
out << "#undef DBL_MIN_10_EXP" << '\n';
|
|
out << "#undef DBL_MAX_10_EXP" << '\n';
|
|
out << "#undef DBL_TRAPS" << '\n';
|
|
out << "#undef DBL_TINYNESS_BEFORE" << '\n';
|
|
out << "#undef DBL_MIN" << '\n';
|
|
out << "#undef DBL_MAX" << '\n';
|
|
out << "#undef DBL_EPSILON" << '\n';
|
|
out << "#undef DBL_INF" << '\n';
|
|
out << "#undef DBL_QUIET_NAN" << '\n';
|
|
out << "#undef DBL_SIGNALING_NAN" << '\n';
|
|
out << "#undef DBL_DENORM_MIN" << '\n';
|
|
out << "#undef DBL_ROUND_ERR" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
|
|
out << R"(/// \brief Does \emph{double} have an infinity?)" << '\n';
|
|
out << "#define DBL_HAS_INFINITY " << std::dec << std::numeric_limits<double>::has_infinity << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{double} have a quiet NaN?)" << '\n';
|
|
out << "#define DBL_HAS_QUIET_NAN " << std::dec << std::numeric_limits<double>::has_quiet_NaN << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{double} have a signaling NaN?)" << '\n';
|
|
out << "#define DBL_HAS_SIGNALING_NAN " << std::dec << std::numeric_limits<double>::has_signaling_NaN << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{double} use denormalization?)" << '\n';
|
|
out << "#define DBL_HAS_DENORM " << std::dec << std::numeric_limits<double>::has_denorm << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{double} have loss with denormalization?)" << '\n';
|
|
out << "#define DBL_HAS_DENORM_LOSS " << std::dec << std::numeric_limits<double>::has_denorm_loss << '\n';
|
|
|
|
out << R"(/// \brief What rounding style does \emph{double} use?)" << '\n';
|
|
out << "#define DBL_ROUNDS " << std::dec << std::numeric_limits<double>::round_style << '\n';
|
|
|
|
out << R"(/// \brief Does \emph{double} use the IEEE doubleing point specification?)" << '\n';
|
|
out << "#define DBL_IS_IEC559 " << std::dec << std::numeric_limits<double>::is_iec559 << '\n';
|
|
|
|
out << R"(/// \brief The number of mantissa bits in \emph{double}.)" << '\n';
|
|
out << "#define DBL_MANT_DIG " << std::dec << std::numeric_limits<double>::digits << '\n';
|
|
|
|
out << R"(/// \brief The number of decimal digits guaranteed to be preserved in a \emph{double} → \emph{text} → \emph{double}.)" << '\n';
|
|
out << "#define DBL_DIG " << std::dec << std::numeric_limits<double>::digits10 << '\n';
|
|
|
|
out << R"(/// \brief The decimal precision required to serialize and deserialize a \emph{double}.)" << '\n';
|
|
out << "#define DBL_DECIMAL_DIG " << std::dec << std::numeric_limits<double>::max_digits10 << '\n';
|
|
|
|
out << R"(/// \brief The radix, or integer base, used to represent a \emph{double}.)" << '\n';
|
|
out << "#define DBL_RADIX " << std::dec << std::numeric_limits<double>::radix << '\n';
|
|
|
|
out << R"(/// \brief The minimum negative integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.)" << '\n';
|
|
out << "#define DBL_MIN_EXP " << std::dec << std::numeric_limits<double>::min_exponent << '\n';
|
|
|
|
out << R"(/// \brief The maximum positive integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.)" << '\n';
|
|
out << "#define DBL_MAX_EXP " << std::dec << std::numeric_limits<double>::max_exponent << '\n';
|
|
|
|
out << R"(/// \brief The minimum negative integer such that \math{{10}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.)" << '\n';
|
|
out << "#define DBL_MIN_10_EXP " << std::dec << std::numeric_limits<double>::min_exponent10 << '\n';
|
|
|
|
out << R"(/// \brief The maximum positive integer such that \math{{10}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.)" << '\n';
|
|
out << "#define DBL_MAX_10_EXP " << std::dec << std::numeric_limits<double>::max_exponent10 << '\n';
|
|
|
|
out << R"(/// \brief Do arithmetics operations with \emph{double} trap?)" << '\n';
|
|
out << "#define DBL_TRAPS " << std::dec << std::numeric_limits<double>::traps << '\n';
|
|
|
|
out << R"(/// \brief Do arithmetics operations with \emph{double} check for underflow?)" << '\n';
|
|
out << "#define DBL_TINYNESS_BEFORE " << std::dec << std::numeric_limits<double>::tinyness_before << '\n';
|
|
|
|
|
|
out << R"(/// \brief Smallest positive, finite, normal value of \emph{double}.)" << '\n';
|
|
out << "#define DBL_MIN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::min() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief Largest positive, finite value of \emph{double}.)" << '\n';
|
|
out << "#define DBL_MAX " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::max() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief The difference between \emph{1.0} and the next representable value of \emph{double}.)" << '\n';
|
|
out << "#define DBL_EPSILON " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::epsilon() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{\inf} of type \emph{double}.)" << '\n';
|
|
out << "#define DBL_INF " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::infinity() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{NaN} of type \emph{double} that does not trap.)" << '\n';
|
|
out << "#define DBL_QUIET_NAN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::quiet_NaN() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief A value representing \emph{NaN} of type \emph{double} that traps.)" << '\n';
|
|
out << "#define DBL_SIGNALING_NAN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::signaling_NaN()) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief Smallest positive, finite, subnormal value of \emph{double}.)" << '\n';
|
|
out << "#define DBL_DENORM_MIN " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::denorm_min() ) << "ll)" << '\n';
|
|
|
|
out << R"(/// \brief Maximum rounding error of type \emph{double}.)" << '\n';
|
|
out << "#define DBL_ROUND_ERR " << "fennec::bit_cast<double>(0x" << std::hex << std::bit_cast<long long>(std::numeric_limits<double>::round_error() ) << "ll)" << '\n';
|
|
|
|
out << "" << '\n';
|
|
|
|
out << "#endif // FENNEC_LANG_FLOAT_H" << '\n';
|
|
|
|
out.close();
|
|
|
|
return;
|
|
}
|
|
|
|
#endif //FLOAT_H
|