mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-17 13:53:57 -07:00
157c6af18e
Avoid cases of filenames Update years in terms and other legal(ish) documents Don't update years in license headers, since change is not meaningful Will add linter rule in seperate commit Happy recompiling everyone! Original Patch By: Nescio Comment By: Gallaecio Differential Revision: D2620 This was SVN commit r27786.
400 lines
12 KiB
C++
400 lines
12 KiB
C++
/* Copyright (C) 2022 Wildfire Games.
|
||
* This file is part of 0 A.D.
|
||
*
|
||
* 0 A.D. 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 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#ifndef INCLUDED_FIXED
|
||
#define INCLUDED_FIXED
|
||
|
||
#include "lib/types.h"
|
||
#include "maths/Sqrt.h"
|
||
#include "ps/CStrForward.h"
|
||
|
||
#ifndef NDEBUG
|
||
#define USE_FIXED_OVERFLOW_CHECKS
|
||
#endif
|
||
|
||
#if MSC_VERSION
|
||
// i32*i32 -> i64 multiply: MSVC x86 doesn't optimise i64 multiplies automatically, so use the intrinsic
|
||
#include <intrin.h>
|
||
#define MUL_I64_I32_I32(a, b)\
|
||
(__emul((a), (b)))
|
||
#define SQUARE_U64_FIXED(a)\
|
||
static_cast<u64>(__emul((a).GetInternalValue(), (a).GetInternalValue()))
|
||
#else
|
||
#define MUL_I64_I32_I32(a, b)\
|
||
static_cast<i64>(a) * static_cast<i64>(b)
|
||
#define SQUARE_U64_FIXED(a)\
|
||
static_cast<u64>(static_cast<i64>((a).GetInternalValue()) * static_cast<i64>((a).GetInternalValue()))
|
||
#endif
|
||
|
||
//define overflow macros
|
||
#ifndef USE_FIXED_OVERFLOW_CHECKS
|
||
|
||
#define CheckSignedSubtractionOverflow(type, left, right, overflowWarning, underflowWarning)
|
||
#define CheckSignedAdditionOverflow(type, left, right, overflowWarning, underflowWarning)
|
||
#define CheckCastOverflow(var, targetType, overflowWarning, underflowWarning)
|
||
#define CheckU32CastOverflow(var, targetType, overflowWarning)
|
||
#define CheckUnsignedAdditionOverflow(result, operand, overflowWarning)
|
||
#define CheckUnsignedSubtractionOverflow(result, operand, overflowWarning)
|
||
#define CheckNegationOverflow(var, type, overflowWarning)
|
||
#define CheckMultiplicationOverflow(type, left, right, overflowWarning, underflowWarning)
|
||
#define CheckDivisionOverflow(type, left, right, overflowWarning)
|
||
|
||
#else // USE_FIXED_OVERFLOW_CHECKS
|
||
|
||
#define CheckSignedSubtractionOverflow(type, left, right, overflowWarning, underflowWarning) \
|
||
if(left > 0 && right < 0 && left > std::numeric_limits<type>::max() + right) \
|
||
debug_warn(overflowWarning); \
|
||
else if(left < 0 && right > 0 && left < std::numeric_limits<type>::min() + right) \
|
||
debug_warn(underflowWarning);
|
||
|
||
#define CheckSignedAdditionOverflow(type, left, right, overflowWarning, underflowWarning) \
|
||
if(left > 0 && right > 0 && std::numeric_limits<type>::max() - left < right) \
|
||
debug_warn(overflowWarning); \
|
||
else if(left < 0 && right < 0 && std::numeric_limits<type>::min() - left > right) \
|
||
debug_warn(underflowWarning);
|
||
|
||
#define CheckCastOverflow(var, targetType, overflowWarning, underflowWarning) \
|
||
if(var > std::numeric_limits<targetType>::max()) \
|
||
debug_warn(overflowWarning); \
|
||
else if(var < std::numeric_limits<targetType>::min()) \
|
||
debug_warn(underflowWarning);
|
||
|
||
#define CheckU32CastOverflow(var, targetType, overflowWarning) \
|
||
if(var > (u32)std::numeric_limits<targetType>::max()) \
|
||
debug_warn(overflowWarning);
|
||
|
||
#define CheckUnsignedAdditionOverflow(result, operand, overflowWarning) \
|
||
if(result < operand) \
|
||
debug_warn(overflowWarning);
|
||
|
||
#define CheckUnsignedSubtractionOverflow(result, left, overflowWarning) \
|
||
if(result > left) \
|
||
debug_warn(overflowWarning);
|
||
|
||
#define CheckNegationOverflow(var, type, overflowWarning) \
|
||
if(value == std::numeric_limits<type>::min()) \
|
||
debug_warn(overflowWarning);
|
||
|
||
#define CheckMultiplicationOverflow(type, left, right, overflowWarning, underflowWarning) \
|
||
i64 res##left = (i64)left * (i64)right; \
|
||
CheckCastOverflow(res##left, type, overflowWarning, underflowWarning)
|
||
|
||
#define CheckDivisionOverflow(type, left, right, overflowWarning) \
|
||
if(right == -1) { CheckNegationOverflow(left, type, overflowWarning) }
|
||
|
||
#endif // USE_FIXED_OVERFLOW_CHECKS
|
||
|
||
template <typename T>
|
||
inline T round_away_from_zero(float value)
|
||
{
|
||
return (T)(value >= 0 ? value + 0.5f : value - 0.5f);
|
||
}
|
||
|
||
template <typename T>
|
||
inline T round_away_from_zero(double value)
|
||
{
|
||
return (T)(value >= 0 ? value + 0.5 : value - 0.5);
|
||
}
|
||
|
||
/**
|
||
* A simple fixed-point number class.
|
||
*
|
||
* Use 'fixed' rather than using this class directly.
|
||
*/
|
||
template<typename T, T max_t, int total_bits, int int_bits, int fract_bits_, int fract_pow2>
|
||
class CFixed
|
||
{
|
||
private:
|
||
T value;
|
||
|
||
constexpr explicit CFixed(T v) : value(v) { }
|
||
|
||
public:
|
||
enum { fract_bits = fract_bits_ };
|
||
|
||
CFixed() : value(0) { }
|
||
|
||
static CFixed Zero() { return CFixed(0); }
|
||
static CFixed Epsilon() { return CFixed(1); }
|
||
static CFixed Pi();
|
||
|
||
T GetInternalValue() const { return value; }
|
||
void SetInternalValue(T n) { value = n; }
|
||
|
||
// Conversion to/from primitive types:
|
||
|
||
static constexpr CFixed FromInt(int n)
|
||
{
|
||
return CFixed(n << fract_bits);
|
||
}
|
||
|
||
// TODO C++20: this won't be necessary when operator/(int) can be made constexpr.
|
||
static constexpr CFixed FromFraction(int n, int d)
|
||
{
|
||
return CFixed(static_cast<int>(static_cast<unsigned int>(n) << fract_bits) / d);
|
||
}
|
||
|
||
static constexpr CFixed FromFloat(float n)
|
||
{
|
||
if (!std::isfinite(n))
|
||
return CFixed(0);
|
||
float scaled = n * fract_pow2;
|
||
return CFixed(round_away_from_zero<T>(scaled));
|
||
}
|
||
|
||
static constexpr CFixed FromDouble(double n)
|
||
{
|
||
if (!std::isfinite(n))
|
||
return CFixed(0);
|
||
double scaled = n * fract_pow2;
|
||
return CFixed(round_away_from_zero<T>(scaled));
|
||
}
|
||
|
||
static CFixed FromString(const CStr8& s);
|
||
static CFixed FromString(const CStrW& s);
|
||
|
||
/// Convert to float. May be lossy - float can't represent all values.
|
||
float ToFloat() const
|
||
{
|
||
return (float)value / (float)fract_pow2;
|
||
}
|
||
|
||
/// Convert to double. Won't be lossy - double can precisely represent all values.
|
||
double ToDouble() const
|
||
{
|
||
return value / (double)fract_pow2;
|
||
}
|
||
|
||
constexpr int ToInt_RoundToZero() const
|
||
{
|
||
if (value > 0)
|
||
return value >> fract_bits;
|
||
else
|
||
return (value + fract_pow2 - 1) >> fract_bits;
|
||
}
|
||
|
||
constexpr int ToInt_RoundToInfinity() const
|
||
{
|
||
return (value + fract_pow2 - 1) >> fract_bits;
|
||
}
|
||
|
||
constexpr int ToInt_RoundToNegInfinity() const
|
||
{
|
||
return value >> fract_bits;
|
||
}
|
||
|
||
constexpr int ToInt_RoundToNearest() const // (ties to infinity)
|
||
{
|
||
return (value + fract_pow2/2) >> fract_bits;
|
||
}
|
||
|
||
/// Returns the shortest string such that FromString will parse to the correct value.
|
||
CStr8 ToString() const;
|
||
|
||
/// Returns true if the number is precisely 0.
|
||
constexpr bool IsZero() const { return value == 0; }
|
||
|
||
/// Equality.
|
||
constexpr bool operator==(CFixed n) const { return (value == n.value); }
|
||
|
||
/// Inequality.
|
||
constexpr bool operator!=(CFixed n) const { return (value != n.value); }
|
||
|
||
/// Numeric comparison.
|
||
constexpr bool operator<=(CFixed n) const { return (value <= n.value); }
|
||
|
||
/// Numeric comparison.
|
||
constexpr bool operator<(CFixed n) const { return (value < n.value); }
|
||
|
||
/// Numeric comparison.
|
||
constexpr bool operator>=(CFixed n) const { return (value >= n.value); }
|
||
|
||
/// Numeric comparison.
|
||
constexpr bool operator>(CFixed n) const { return (value > n.value); }
|
||
|
||
// Basic arithmetic:
|
||
|
||
/// Add a CFixed. Might overflow.
|
||
CFixed operator+(CFixed n) const
|
||
{
|
||
CheckSignedAdditionOverflow(T, value, n.value, L"Overflow in CFixed::operator+(CFixed n)", L"Underflow in CFixed::operator+(CFixed n)")
|
||
return CFixed(value + n.value);
|
||
}
|
||
|
||
/// Subtract a CFixed. Might overflow.
|
||
CFixed operator-(CFixed n) const
|
||
{
|
||
CheckSignedSubtractionOverflow(T, value, n.value, L"Overflow in CFixed::operator-(CFixed n)", L"Underflow in CFixed::operator-(CFixed n)")
|
||
return CFixed(value - n.value);
|
||
}
|
||
|
||
/// Add a CFixed. Might overflow.
|
||
constexpr CFixed& operator+=(CFixed n) { *this = *this + n; return *this; }
|
||
|
||
/// Subtract a CFixed. Might overflow.
|
||
constexpr CFixed& operator-=(CFixed n) { *this = *this - n; return *this; }
|
||
|
||
/// Negate a CFixed.
|
||
CFixed operator-() const
|
||
{
|
||
CheckNegationOverflow(value, T, L"Overflow in CFixed::operator-()")
|
||
return CFixed(-value);
|
||
}
|
||
|
||
CFixed operator>>(int n) const
|
||
{
|
||
ASSERT(n >= 0 && n < 32);
|
||
return CFixed(value >> n);
|
||
}
|
||
|
||
CFixed operator<<(int n) const
|
||
{
|
||
ASSERT(n >= 0 && n < 32);
|
||
// TODO: check for overflow
|
||
return CFixed(value << n);
|
||
}
|
||
|
||
/// Divide by a CFixed. Must not have n.IsZero(). Might overflow.
|
||
CFixed operator/(CFixed n) const
|
||
{
|
||
i64 t = (i64)value << fract_bits;
|
||
i64 result = t / (i64)n.value;
|
||
|
||
CheckCastOverflow(result, T, L"Overflow in CFixed::operator/(CFixed n)", L"Underflow in CFixed::operator/(CFixed n)")
|
||
return CFixed((T)result);
|
||
}
|
||
|
||
/// Multiply by an integer. Might overflow.
|
||
CFixed operator*(int n) const
|
||
{
|
||
CheckMultiplicationOverflow(T, value, n, L"Overflow in CFixed::operator*(int n)", L"Underflow in CFixed::operator*(int n)")
|
||
return CFixed(value * n);
|
||
}
|
||
|
||
/// Multiply by an integer. Avoids overflow by clamping to min/max representable value.
|
||
constexpr CFixed MultiplyClamp(int n) const
|
||
{
|
||
i64 t = (i64)value * n;
|
||
t = std::max((i64)std::numeric_limits<T>::min(), std::min((i64)std::numeric_limits<T>::max(), t));
|
||
return CFixed((i32)t);
|
||
}
|
||
|
||
/// Divide by an integer. Must not have n == 0. Cannot overflow unless n == -1.
|
||
CFixed operator/(int n) const
|
||
{
|
||
CheckDivisionOverflow(T, value, n, L"Overflow in CFixed::operator/(int n)")
|
||
return CFixed(value / n);
|
||
}
|
||
|
||
/// Mod by a fixed. Must not have n == 0. Result has the same sign as n.
|
||
constexpr CFixed operator%(CFixed n) const
|
||
{
|
||
T t = value % n.value;
|
||
if (n.value > 0 && t < 0)
|
||
t += n.value;
|
||
else if (n.value < 0 && t > 0)
|
||
t += n.value;
|
||
|
||
return CFixed(t);
|
||
}
|
||
|
||
constexpr CFixed Absolute() const { return CFixed(abs(value)); }
|
||
|
||
/**
|
||
* Multiply by a CFixed. Likely to overflow if both numbers are large,
|
||
* so we use an ugly name instead of operator* to make it obvious.
|
||
*/
|
||
CFixed Multiply(CFixed n) const
|
||
{
|
||
i64 t = MUL_I64_I32_I32(value, n.value);
|
||
t >>= fract_bits;
|
||
|
||
CheckCastOverflow(t, T, L"Overflow in CFixed::Multiply(CFixed n)", L"Underflow in CFixed::Multiply(CFixed n)")
|
||
return CFixed((T)t);
|
||
}
|
||
|
||
/**
|
||
* Multiply the value by itself. Might overflow.
|
||
*/
|
||
constexpr CFixed Square() const
|
||
{
|
||
return (*this).Multiply(*this);
|
||
}
|
||
|
||
/**
|
||
* Compute this*m/d. Must not have d == 0. Won't overflow if the result can be represented as a CFixed.
|
||
*/
|
||
CFixed MulDiv(CFixed m, CFixed d) const
|
||
{
|
||
i64 t = MUL_I64_I32_I32(value, m.value) / static_cast<i64>(d.value);
|
||
CheckCastOverflow(t, T, L"Overflow in CFixed::Multiply(CFixed n)", L"Underflow in CFixed::Multiply(CFixed n)")
|
||
return CFixed((T)t);
|
||
}
|
||
|
||
constexpr CFixed Sqrt() const
|
||
{
|
||
if (value <= 0)
|
||
return CFixed(0);
|
||
u32 s = isqrt64((u64)value << fract_bits);
|
||
return CFixed(s);
|
||
}
|
||
|
||
private:
|
||
// Prevent dangerous accidental implicit conversions of floats to ints in certain operations
|
||
CFixed operator*(float n) const;
|
||
CFixed operator/(float n) const;
|
||
};
|
||
|
||
/**
|
||
* A fixed-point number class with 1-bit sign, 15-bit integral part, 16-bit fractional part.
|
||
*/
|
||
typedef CFixed<i32, (i32)0x7fffffff, 32, 15, 16, 65536> CFixed_15_16;
|
||
|
||
/**
|
||
* Default fixed-point type used by the engine.
|
||
*/
|
||
typedef CFixed_15_16 fixed;
|
||
|
||
namespace std
|
||
{
|
||
/**
|
||
* std::numeric_limits specialisation, currently just providing min and max
|
||
*/
|
||
template<typename T, T max_t, int total_bits, int int_bits, int fract_bits_, int fract_pow2>
|
||
struct numeric_limits<CFixed<T, max_t, total_bits, int_bits, fract_bits_, fract_pow2> >
|
||
{
|
||
typedef CFixed<T, max_t, total_bits, int_bits, fract_bits_, fract_pow2> fixed;
|
||
public:
|
||
static const bool is_specialized = true;
|
||
static fixed min() throw() { fixed f; f.SetInternalValue(std::numeric_limits<T>::min()); return f; }
|
||
static fixed max() throw() { fixed f; f.SetInternalValue(std::numeric_limits<T>::max()); return f; }
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Inaccurate approximation of atan2 over fixed-point numbers.
|
||
* Maximum error is almost 0.08 radians (4.5 degrees).
|
||
*/
|
||
CFixed_15_16 atan2_approx(CFixed_15_16 y, CFixed_15_16 x);
|
||
|
||
/**
|
||
* Compute sin(a) and cos(a).
|
||
* Maximum error for -2pi < a < 2pi is almost 0.0005.
|
||
*/
|
||
void sincos_approx(CFixed_15_16 a, CFixed_15_16& sin_out, CFixed_15_16& cos_out);
|
||
|
||
#endif // INCLUDED_FIXED
|