3#include <CesiumUtility/Library.h>
5#include <glm/gtc/epsilon.hpp>
6#include <glm/mat4x4.hpp>
13class CESIUMUTILITY_API
Math final {
81 static constexpr double OnePi = 3.14159265358979323846;
116 template <glm::length_t L,
typename T, glm::qualifier Q>
118 const glm::vec<L, T, Q>& a,
119 const glm::vec<L, T, Q>& b,
120 double relativeEpsilon)
noexcept {
121 return relativeEpsilon * glm::max(glm::abs(a), glm::abs(b));
136 double relativeEpsilon)
noexcept {
137 return relativeEpsilon * glm::max(glm::abs(a), glm::abs(b));
152 template <glm::length_t L,
typename T, glm::qualifier Q>
154 const glm::vec<L, T, Q>& left,
155 const glm::vec<L, T, Q>& right,
156 double relativeEpsilon)
noexcept {
168 static constexpr bool
170 return equalsEpsilon(left, right, relativeEpsilon, relativeEpsilon);
197 double relativeEpsilon,
198 double absoluteEpsilon)
noexcept {
199 const double diff = glm::abs(left - right);
200 return diff <= absoluteEpsilon ||
227 template <glm::length_t L,
typename T, glm::qualifier Q>
229 const glm::vec<L, T, Q>& left,
230 const glm::vec<L, T, Q>& right,
231 double relativeEpsilon,
232 double absoluteEpsilon)
noexcept {
233 const glm::vec<L, T, Q> diff = glm::abs(left - right);
234 return glm::lessThanEqual(diff, glm::vec<L, T, Q>(absoluteEpsilon)) ==
235 glm::vec<L, bool, Q>(
true) ||
239 glm::vec<L, bool, Q>(
true);
264 template <
typename T, glm::qualifier Q>
266 const glm::mat<4, 4, T, Q>& left,
267 const glm::mat<4, 4, T, Q>& right,
268 double relativeEpsilon,
269 double absoluteEpsilon)
noexcept {
270 for (glm::length_t i = 0; i < 4; ++i) {
271 if (!
equalsEpsilon(left[i], right[i], relativeEpsilon, absoluteEpsilon)) {
287 static constexpr double sign(
double value)
noexcept {
288 if (value == 0.0 || value != value) {
292 return value > 0 ? 1 : -1;
306 return value < 0.0 ? -1.0 : 1.0;
352 static double mod(
double m,
double n)
noexcept {
358 return fmod(fmod(m, n) + n, n);
391 static double lerp(
double p,
double q,
double time)
noexcept {
392 return glm::mix(p, q, time);
403 static constexpr double clamp(
double value,
double min,
double max)
noexcept {
404 return glm::clamp(value, min, max);
417 static double toSNorm(
double value,
double rangeMaximum = 255.0) noexcept {
419 (
Math::clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
431 static constexpr double
432 fromSNorm(
double value,
double rangeMaximum = 255.0) noexcept {
433 return (
Math::clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0;
450 const double simplified = angle - glm::floor(angle / twoPi) * twoPi;
453 return simplified + twoPi;
456 return simplified - twoPi;
472 static double roundUp(
double value,
double tolerance)
noexcept {
473 const double up = glm::ceil(value);
474 const double down = glm::floor(value);
475 if (value - down < tolerance) {
492 static double roundDown(
double value,
double tolerance)
noexcept {
493 const double up = glm::ceil(value);
494 const double down = glm::floor(value);
495 if (up - value < tolerance) {
Mathematical constants and functions.
static constexpr double Epsilon14
0.00000000000001
static double mod(double m, double n) noexcept
The modulo operation that also works for negative dividends.
static constexpr double radiansToDegrees(double angleRadians) noexcept
Converts radians to degrees.
static constexpr double degreesToRadians(double angleDegrees) noexcept
Converts degrees to radians.
static constexpr double Epsilon12
0.000000000001
static constexpr double Epsilon20
0.00000000000000000001
static constexpr bool equalsEpsilon(const glm::vec< L, T, Q > &left, const glm::vec< L, T, Q > &right, double relativeEpsilon, double absoluteEpsilon) noexcept
Determines if two values are equal using an absolute or relative tolerance test.
static constexpr double PiOverFour
Pi divided by four.
static constexpr double Epsilon9
0.000000001
static constexpr glm::vec< L, T, Q > relativeEpsilonToAbsolute(const glm::vec< L, T, Q > &a, const glm::vec< L, T, Q > &b, double relativeEpsilon) noexcept
Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.
static constexpr double Epsilon4
0.0001
static constexpr bool equalsEpsilon(double left, double right, double relativeEpsilon, double absoluteEpsilon) noexcept
Determines if two values are equal using an absolute or relative tolerance test.
static constexpr double Epsilon21
0.000000000000000000001
static double toSNorm(double value, double rangeMaximum=255.0) noexcept
Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].
static constexpr double sign(double value) noexcept
Returns the sign of the value.
static constexpr double TwoPi
Two times pi.
static constexpr double PiOverTwo
Pi divided by two.
static bool constexpr equalsEpsilon(const glm::vec< L, T, Q > &left, const glm::vec< L, T, Q > &right, double relativeEpsilon) noexcept
Checks whether two values are equal up to a given relative epsilon.
static constexpr double Epsilon13
0.0000000000001
static constexpr double Epsilon16
0.0000000000000001
static constexpr double Epsilon1
0.1
static constexpr double OnePi
Pi.
static constexpr double Epsilon2
0.01
static double roundUp(double value, double tolerance) noexcept
Rounds a value up to the nearest integer, like ceil, except that if the value is very close to the lo...
static double negativePiToPi(double angle) noexcept
Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
static double zeroToTwoPi(double angle) noexcept
Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
static constexpr bool equalsEpsilon(double left, double right, double relativeEpsilon) noexcept
Checks whether two values are equal up to a given relative epsilon.
static constexpr double Epsilon18
0.000000000000000001
static constexpr double Epsilon10
0.0000000001
static double roundDown(double value, double tolerance) noexcept
Rounds a value down to the nearest integer, like floor, except that if the value is very close to the...
static constexpr bool equalsEpsilon(const glm::mat< 4, 4, T, Q > &left, const glm::mat< 4, 4, T, Q > &right, double relativeEpsilon, double absoluteEpsilon) noexcept
Determines if two values are equal using an absolute or relative tolerance test.
static constexpr double clamp(double value, double min, double max) noexcept
Constrain a value to lie between two values.
static constexpr double Epsilon17
0.00000000000000001
static double lerp(double p, double q, double time) noexcept
Computes the linear interpolation of two values.
static double convertLongitudeRange(double angle) noexcept
static constexpr double signNotZero(double value) noexcept
Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.
static constexpr double relativeEpsilonToAbsolute(double a, double b, double relativeEpsilon) noexcept
Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.
static constexpr double Epsilon15
0.000000000000001
static constexpr double Epsilon6
0.000001
static constexpr double Epsilon7
0.0000001
static constexpr double Epsilon3
0.001
static constexpr double Epsilon5
0.00001
static constexpr double fromSNorm(double value, double rangeMaximum=255.0) noexcept
Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1....
static constexpr double Epsilon11
0.00000000001
static constexpr double GoldenRatio
The golden ratio, (1.0 + sqrt(5.0)) / 2.0.
static constexpr double Epsilon19
0.0000000000000000001
static constexpr double Epsilon8
0.00000001
Utility classes for Cesium.