cesium-native 0.48.0
Loading...
Searching...
No Matches
Math.h
1#pragma once
2
3#include <CesiumUtility/Library.h>
4
5#include <glm/gtc/epsilon.hpp>
6#include <glm/mat4x4.hpp>
7
8namespace CesiumUtility {
9
13class CESIUMUTILITY_API Math final {
14public:
16 static constexpr double Epsilon1 = 1e-1;
17
19 static constexpr double Epsilon2 = 1e-2;
20
22 static constexpr double Epsilon3 = 1e-3;
23
25 static constexpr double Epsilon4 = 1e-4;
26
28 static constexpr double Epsilon5 = 1e-5;
29
31 static constexpr double Epsilon6 = 1e-6;
32
34 static constexpr double Epsilon7 = 1e-7;
35
37 static constexpr double Epsilon8 = 1e-8;
38
40 static constexpr double Epsilon9 = 1e-9;
41
43 static constexpr double Epsilon10 = 1e-10;
44
46 static constexpr double Epsilon11 = 1e-11;
47
49 static constexpr double Epsilon12 = 1e-12;
50
52 static constexpr double Epsilon13 = 1e-13;
53
55 static constexpr double Epsilon14 = 1e-14;
56
58 static constexpr double Epsilon15 = 1e-15;
59
61 static constexpr double Epsilon16 = 1e-16;
62
64 static constexpr double Epsilon17 = 1e-17;
65
67 static constexpr double Epsilon18 = 1e-18;
68
70 static constexpr double Epsilon19 = 1e-19;
71
73 static constexpr double Epsilon20 = 1e-20;
74
76 static constexpr double Epsilon21 = 1e-21;
77
81 static constexpr double OnePi = 3.14159265358979323846;
82
86 static constexpr double TwoPi = OnePi * 2.0;
87
91 static constexpr double PiOverTwo = OnePi / 2.0;
92
96 static constexpr double PiOverFour = OnePi / 4.0;
97
101 static constexpr double GoldenRatio = 1.61803398874989484;
102
116 template <glm::length_t L, typename T, glm::qualifier Q>
117 static constexpr glm::vec<L, T, Q> relativeEpsilonToAbsolute(
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));
122 }
123
133 static constexpr double relativeEpsilonToAbsolute(
134 double a,
135 double b,
136 double relativeEpsilon) noexcept {
137 return relativeEpsilon * glm::max(glm::abs(a), glm::abs(b));
138 }
139
152 template <glm::length_t L, typename T, glm::qualifier Q>
153 static bool constexpr equalsEpsilon(
154 const glm::vec<L, T, Q>& left,
155 const glm::vec<L, T, Q>& right,
156 double relativeEpsilon) noexcept {
157 return Math::equalsEpsilon(left, right, relativeEpsilon, relativeEpsilon);
158 }
159
168 static constexpr bool
169 equalsEpsilon(double left, double right, double relativeEpsilon) noexcept {
170 return equalsEpsilon(left, right, relativeEpsilon, relativeEpsilon);
171 }
172
194 static constexpr bool equalsEpsilon(
195 double left,
196 double right,
197 double relativeEpsilon,
198 double absoluteEpsilon) noexcept {
199 const double diff = glm::abs(left - right);
200 return diff <= absoluteEpsilon ||
201 diff <= relativeEpsilonToAbsolute(left, right, relativeEpsilon);
202 }
203
227 template <glm::length_t L, typename T, glm::qualifier Q>
228 static constexpr bool equalsEpsilon(
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) ||
236 glm::lessThanEqual(
237 diff,
238 relativeEpsilonToAbsolute(left, right, relativeEpsilon)) ==
239 glm::vec<L, bool, Q>(true);
240 }
241
264 template <typename T, glm::qualifier Q>
265 static constexpr bool equalsEpsilon(
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)) {
272 return false;
273 }
274 }
275 return true;
276 }
277
287 static constexpr double sign(double value) noexcept {
288 if (value == 0.0 || value != value) {
289 // zero or NaN
290 return value;
291 }
292 return value > 0 ? 1 : -1;
293 }
294
305 static constexpr double signNotZero(double value) noexcept {
306 return value < 0.0 ? -1.0 : 1.0;
307 }
308
316 static double negativePiToPi(double angle) noexcept {
317 if (angle >= -Math::OnePi && angle <= Math::OnePi) {
318 // Early exit if the input is already inside the range. This avoids
319 // unnecessary math which could introduce floating point error.
320 return angle;
321 }
322 return Math::zeroToTwoPi(angle + Math::OnePi) - Math::OnePi;
323 }
324
332 static double zeroToTwoPi(double angle) noexcept {
333 if (angle >= 0 && angle <= Math::TwoPi) {
334 // Early exit if the input is already inside the range. This avoids
335 // unnecessary math which could introduce floating point error.
336 return angle;
337 }
338 const double mod = Math::mod(angle, Math::TwoPi);
339 if (glm::abs(mod) < Math::Epsilon14 && glm::abs(angle) > Math::Epsilon14) {
340 return Math::TwoPi;
341 }
342 return mod;
343 }
344
352 static double mod(double m, double n) noexcept {
353 if (Math::sign(m) == Math::sign(n) && glm::abs(m) < glm::abs(n)) {
354 // Early exit if the input does not need to be modded. This avoids
355 // unnecessary math which could introduce floating point error.
356 return m;
357 }
358 return fmod(fmod(m, n) + n, n);
359 }
360
367 static constexpr double degreesToRadians(double angleDegrees) noexcept {
368 return angleDegrees * Math::OnePi / 180.0;
369 }
370
377 static constexpr double radiansToDegrees(double angleRadians) noexcept {
378 return angleRadians * 180.0 / Math::OnePi;
379 }
380
391 static double lerp(double p, double q, double time) noexcept {
392 return glm::mix(p, q, time);
393 }
394
403 static constexpr double clamp(double value, double min, double max) noexcept {
404 return glm::clamp(value, min, max);
405 };
406
417 static double toSNorm(double value, double rangeMaximum = 255.0) noexcept {
418 return glm::round(
419 (Math::clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
420 };
421
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;
434 }
435
447 static double convertLongitudeRange(double angle) noexcept {
448 constexpr double twoPi = Math::TwoPi;
449
450 const double simplified = angle - glm::floor(angle / twoPi) * twoPi;
451
452 if (simplified < -Math::OnePi) {
453 return simplified + twoPi;
454 }
455 if (simplified >= Math::OnePi) {
456 return simplified - twoPi;
457 }
458
459 return simplified;
460 };
461
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) {
476 return down;
477 } else {
478 return up;
479 }
480 }
481
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) {
496 return up;
497 } else {
498 return down;
499 }
500 }
501};
502
503} // namespace CesiumUtility
Mathematical constants and functions.
Definition Math.h:13
static constexpr double Epsilon14
0.00000000000001
Definition Math.h:55
static double mod(double m, double n) noexcept
The modulo operation that also works for negative dividends.
Definition Math.h:352
static constexpr double radiansToDegrees(double angleRadians) noexcept
Converts radians to degrees.
Definition Math.h:377
static constexpr double degreesToRadians(double angleDegrees) noexcept
Converts degrees to radians.
Definition Math.h:367
static constexpr double Epsilon12
0.000000000001
Definition Math.h:49
static constexpr double Epsilon20
0.00000000000000000001
Definition Math.h:73
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.
Definition Math.h:228
static constexpr double PiOverFour
Pi divided by four.
Definition Math.h:96
static constexpr double Epsilon9
0.000000001
Definition Math.h:40
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.
Definition Math.h:117
static constexpr double Epsilon4
0.0001
Definition Math.h:25
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.
Definition Math.h:194
static constexpr double Epsilon21
0.000000000000000000001
Definition Math.h:76
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].
Definition Math.h:417
static constexpr double sign(double value) noexcept
Returns the sign of the value.
Definition Math.h:287
static constexpr double TwoPi
Two times pi.
Definition Math.h:86
static constexpr double PiOverTwo
Pi divided by two.
Definition Math.h:91
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.
Definition Math.h:153
static constexpr double Epsilon13
0.0000000000001
Definition Math.h:52
static constexpr double Epsilon16
0.0000000000000001
Definition Math.h:61
static constexpr double Epsilon1
0.1
Definition Math.h:16
static constexpr double OnePi
Pi.
Definition Math.h:81
static constexpr double Epsilon2
0.01
Definition Math.h:19
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...
Definition Math.h:472
static double negativePiToPi(double angle) noexcept
Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
Definition Math.h:316
static double zeroToTwoPi(double angle) noexcept
Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
Definition Math.h:332
static constexpr bool equalsEpsilon(double left, double right, double relativeEpsilon) noexcept
Checks whether two values are equal up to a given relative epsilon.
Definition Math.h:169
static constexpr double Epsilon18
0.000000000000000001
Definition Math.h:67
static constexpr double Epsilon10
0.0000000001
Definition Math.h:43
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...
Definition Math.h:492
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.
Definition Math.h:265
static constexpr double clamp(double value, double min, double max) noexcept
Constrain a value to lie between two values.
Definition Math.h:403
static constexpr double Epsilon17
0.00000000000000001
Definition Math.h:64
static double lerp(double p, double q, double time) noexcept
Computes the linear interpolation of two values.
Definition Math.h:391
static double convertLongitudeRange(double angle) noexcept
Definition Math.h:447
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.
Definition Math.h:305
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.
Definition Math.h:133
static constexpr double Epsilon15
0.000000000000001
Definition Math.h:58
static constexpr double Epsilon6
0.000001
Definition Math.h:31
static constexpr double Epsilon7
0.0000001
Definition Math.h:34
static constexpr double Epsilon3
0.001
Definition Math.h:22
static constexpr double Epsilon5
0.00001
Definition Math.h:28
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....
Definition Math.h:432
static constexpr double Epsilon11
0.00000000001
Definition Math.h:46
static constexpr double GoldenRatio
The golden ratio, (1.0 + sqrt(5.0)) / 2.0.
Definition Math.h:101
static constexpr double Epsilon19
0.0000000000000000001
Definition Math.h:70
static constexpr double Epsilon8
0.00000001
Definition Math.h:37
Utility classes for Cesium.