math.inl - Engine C API Reference

math.inl
  1. #include "assert.h"
  3. namespace stingray_plugin_foundation {
  5. __forceinline bool math::is_pow2(unsigned x)
  6. {
  7.     return (x & (x - 1)) == 0;
  8. }
  10. __forceinline float math::square_root(float f)
  11. {
  12.     return sqrtf(f);
  13. }
  15. __forceinline float math::degrees_to_radians(float f)
  16. {
  17.     return f / 180.0f * pi;
  18. }
  20. __forceinline float math::radians_to_degrees(float f)
  21. {
  22.     return 180.0f * f / pi;
  23. }
  25. template <class T> __forceinline T math::max(T a, T b)
  26. {
  27.     return a > b ? a : b;
  28. }
  30. template <class T> __forceinline T math::max3(T a, T b, T c)
  31. {
  32.     return max(a, max(b,c));
  33. }
  35. template <class T> __forceinline T math::min(T a, T b)
  36. {
  37.     return a < b ? a : b;
  38. }
  40. template <class T> __forceinline T math::min3(T a, T b, T c)
  41. {
  42.     return min(a, min(b,c));
  43. }
  46. template <class T> __forceinline T math::clamp(T x, T min, T max)
  47. {
  48.     if(x>max)
  49.         return max;
  50.     else if(x<min)
  51.         return min;
  52.     else
  53.         return x;
  54. }
  56. template <class T> __forceinline T math::abs(T x)
  57. {
  58.     if (x > 0)
  59.         return x;
  60.     else
  61.         return -x;
  62. }
  64. template <class T> __forceinline T math::sign(T x)
  65. {
  66.     if (x > 0)
  67.         return T(1);
  68.     else if (x == 0)
  69.         return T(0);
  70.     else
  71.         return T(-1);
  72. }
  74. __forceinline unsigned math::branchless_max(unsigned a, unsigned b)
  75. {
  76.     return a - ((a-b) & (a-b)>>31);
  77. }
  79. __forceinline unsigned math::branchless_min(unsigned a, unsigned b)
  80. {
  81.     return b + ((a-b) & (a-b)>>31);
  82. }
  84. __forceinline unsigned math::div_ceil(unsigned a, unsigned b) {
  85.     return (a+b-1)/b;
  86. }
  88. __forceinline unsigned math::div_round(unsigned a, unsigned b) {
  89.     return (a+b/2)/b;
  90. }
  92. __forceinline float lerp(float a, float b, float p)
  93. {
  94.     return a * (1-p) + b * p;
  95. }
  97. inline void Crossfade::update(float dt)
  98. {
  99.     if (_fade_in_t < FLT_MAX) {
  100.         _fade_in += (1 - _fade_in) * dt / _fade_in_t;
  101.         _fade_in_t -= dt;
  102.         if (_fade_in_t <= 0) {
  103.             _fade_in_t = FLT_MAX;
  104.             _fade_in = 1;
  105.         }
  106.     }
  108.     if (_fade_out_t < FLT_MAX) {
  109.         _fade_out += (1 - _fade_out) * dt / _fade_out_t;
  110.         _fade_out_t -= dt;
  111.         if (_fade_out_t <= 0) {
  112.             _fade_out_t = FLT_MAX;
  113.             _fade_out = 1;
  114.         }
  115.     }
  117.     XENSURE(blend() >= 0.0f);
  118. }
  120. }
Please send us your comment about this page