Cleanup.

include/bx/inline/math.inl

@@ -105,22 +105,22 @@ namespace bx
 		return -floor(-_a);
 	}
 
-	inline constexpr BX_CONST_FUNC float lerp(float _a, float _b, float _t)
+	inline BX_CONSTEXPR_FUNC float lerp(float _a, float _b, float _t)
 	{
 		return _a + (_b - _a) * _t;
 	}
 
-	inline constexpr BX_CONST_FUNC float sign(float _a)
+	inline BX_CONSTEXPR_FUNC float sign(float _a)
 	{
 		return _a < 0.0f ? -1.0f : 1.0f;
 	}
 
-	inline constexpr BX_CONST_FUNC float abs(float _a)
+	inline BX_CONSTEXPR_FUNC float abs(float _a)
 	{
 		return _a < 0.0f ? -_a : _a;
 	}
 
-	inline constexpr BX_CONST_FUNC float square(float _a)
+	inline BX_CONSTEXPR_FUNC float square(float _a)
 	{
 		return _a * _a;
 	}
@@ -238,17 +238,17 @@ namespace bx
 #endif // BX_CONFIG_SUPPORTS_SIMD
 	}
 
-	inline constexpr BX_CONST_FUNC float trunc(float _a)
+	inline BX_CONSTEXPR_FUNC float trunc(float _a)
 	{
 		return float(int(_a) );
 	}
 
-	inline constexpr BX_CONST_FUNC float fract(float _a)
+	inline BX_CONSTEXPR_FUNC float fract(float _a)
 	{
 		return _a - trunc(_a);
 	}
 
-	inline constexpr BX_CONST_FUNC float mad(float _a, float _b, float _c)
+	inline BX_CONSTEXPR_FUNC float mad(float _a, float _b, float _c)
 	{
 		return _a * _b + _c;
 	}
@@ -258,7 +258,7 @@ namespace bx
 		return _a - _b * floor(_a / _b);
 	}
 
-	inline constexpr BX_CONST_FUNC bool equal(float _a, float _b, float _epsilon)
+	inline BX_CONSTEXPR_FUNC bool equal(float _a, float _b, float _epsilon)
 	{
 		// Reference(s):
 		// - https://web.archive.org/web/20181103180318/http://realtimecollisiondetection.net/blog/?p=89
@@ -285,27 +285,27 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC float step(float _edge, float _a)
+	inline BX_CONSTEXPR_FUNC float step(float _edge, float _a)
 	{
 		return _a < _edge ? 0.0f : 1.0f;
 	}
 
-	inline constexpr BX_CONST_FUNC float pulse(float _a, float _start, float _end)
+	inline BX_CONSTEXPR_FUNC float pulse(float _a, float _start, float _end)
 	{
 		return step(_a, _start) - step(_a, _end);
 	}
 
-	inline constexpr BX_CONST_FUNC float smoothStep(float _a)
+	inline BX_CONSTEXPR_FUNC float smoothStep(float _a)
 	{
 		return square(_a)*(3.0f - 2.0f*_a);
 	}
 
-	inline constexpr BX_CONST_FUNC float bias(float _time, float _bias)
+	inline BX_CONSTEXPR_FUNC float bias(float _time, float _bias)
 	{
 		return _time / ( ( (1.0f/_bias - 2.0f)*(1.0f - _time) ) + 1.0f);
 	}
 
-	inline constexpr BX_CONST_FUNC float gain(float _time, float _gain)
+	inline BX_CONSTEXPR_FUNC float gain(float _time, float _gain)
 	{
 		// Reference(s):
 		// - Bias And Gain Are Your Friend
@@ -350,7 +350,7 @@ namespace bx
 		ptr[2] = _a.z;
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 abs(const Vec3&  _a)
+	inline BX_CONSTEXPR_FUNC Vec3 abs(const Vec3&  _a)
 	{
 		return
 		{
@@ -360,7 +360,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 neg(const Vec3&  _a)
+	inline BX_CONSTEXPR_FUNC Vec3 neg(const Vec3&  _a)
 	{
 		return
 		{
@@ -370,7 +370,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 add(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 add(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -380,7 +380,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 add(const Vec3&  _a, float _b)
+	inline BX_CONSTEXPR_FUNC Vec3 add(const Vec3&  _a, float _b)
 	{
 		return
 		{
@@ -390,7 +390,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 sub(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 sub(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -400,7 +400,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 sub(const Vec3&  _a, float _b)
+	inline BX_CONSTEXPR_FUNC Vec3 sub(const Vec3&  _a, float _b)
 	{
 		return
 		{
@@ -410,7 +410,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 mul(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 mul(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -420,7 +420,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 mul(const Vec3&  _a, float _b)
+	inline BX_CONSTEXPR_FUNC Vec3 mul(const Vec3&  _a, float _b)
 	{
 		return
 		{
@@ -430,17 +430,17 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 mad(const Vec3& _a, const Vec3& _b, const Vec3& _c)
+	inline BX_CONSTEXPR_FUNC Vec3 mad(const Vec3& _a, const Vec3& _b, const Vec3& _c)
 	{
 		return add(mul(_a, _b), _c);
 	}
 
-	inline constexpr BX_CONST_FUNC float dot(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC float dot(const Vec3&  _a, const Vec3&  _b)
 	{
 		return _a.x*_b.x + _a.y*_b.y + _a.z*_b.z;
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 cross(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 cross(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -455,7 +455,7 @@ namespace bx
 		return sqrt(dot(_a, _a) );
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, float _t)
+	inline BX_CONSTEXPR_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, float _t)
 	{
 		return
 		{
@@ -465,7 +465,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, const Vec3&  _t)
+	inline BX_CONSTEXPR_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, const Vec3&  _t)
 	{
 		return
 		{
@@ -482,7 +482,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 min(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 min(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -492,7 +492,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 max(const Vec3&  _a, const Vec3&  _b)
+	inline BX_CONSTEXPR_FUNC Vec3 max(const Vec3&  _a, const Vec3&  _b)
 	{
 		return
 		{
@@ -502,7 +502,7 @@ namespace bx
 		};
 	}
 
-	inline constexpr BX_CONST_FUNC Vec3 rcp(const Vec3&  _a)
+	inline BX_CONSTEXPR_FUNC Vec3 rcp(const Vec3&  _a)
 	{
 		return
 		{

include/bx/inline/uint32_t.inl

@@ -29,162 +29,162 @@
 
 namespace bx
 {
-	inline constexpr BX_CONST_FUNC uint32_t uint32_li(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_li(uint32_t _a)
 	{
 		return _a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_dec(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_dec(uint32_t _a)
 	{
 		return _a - 1;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_inc(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_inc(uint32_t _a)
 	{
 		return _a + 1;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_not(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_not(uint32_t _a)
 	{
 		return ~_a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_neg(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_neg(uint32_t _a)
 	{
 		return -(int32_t)_a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_ext(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_ext(uint32_t _a)
 	{
 		return ( (int32_t)_a)>>31;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_and(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_and(uint32_t _a, uint32_t _b)
 	{
 		return _a & _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_andc(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_andc(uint32_t _a, uint32_t _b)
 	{
 		return _a & ~_b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_xor(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_xor(uint32_t _a, uint32_t _b)
 	{
 		return _a ^ _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_xorl(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_xorl(uint32_t _a, uint32_t _b)
 	{
 		return !_a != !_b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_or(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_or(uint32_t _a, uint32_t _b)
 	{
 		return _a | _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_orc(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_orc(uint32_t _a, uint32_t _b)
 	{
 		return _a | ~_b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_sll(uint32_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_sll(uint32_t _a, int32_t _sa)
 	{
 		return _a << _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_srl(uint32_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_srl(uint32_t _a, int32_t _sa)
 	{
 		return _a >> _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_sra(uint32_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_sra(uint32_t _a, int32_t _sa)
 	{
 		return ( (int32_t)_a) >> _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_rol(uint32_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_rol(uint32_t _a, int32_t _sa)
 	{
 		return ( _a << _sa) | (_a >> (32-_sa) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_ror(uint32_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_ror(uint32_t _a, int32_t _sa)
 	{
 		return ( _a >> _sa) | (_a << (32-_sa) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_add(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_add(uint32_t _a, uint32_t _b)
 	{
 		return _a + _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_iadd(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_iadd(uint32_t _a, uint32_t _b)
 	{
 		return int32_t(_a) + int32_t(_b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_sub(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_sub(uint32_t _a, uint32_t _b)
 	{
 		return _a - _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_isub(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_isub(uint32_t _a, uint32_t _b)
 	{
 		return int32_t(_a) - int32_t(_b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_mul(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_mul(uint32_t _a, uint32_t _b)
 	{
 		return _a * _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_div(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_div(uint32_t _a, uint32_t _b)
 	{
 		return _a / _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_mod(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_mod(uint32_t _a, uint32_t _b)
 	{
 		return _a % _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmpeq(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmpeq(uint32_t _a, uint32_t _b)
 	{
 		return -(_a == _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmpneq(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmpneq(uint32_t _a, uint32_t _b)
 	{
 		return -(_a != _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmplt(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmplt(uint32_t _a, uint32_t _b)
 	{
 		return -(_a < _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmple(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmple(uint32_t _a, uint32_t _b)
 	{
 		return -(_a <= _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmpgt(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmpgt(uint32_t _a, uint32_t _b)
 	{
 		return -(_a > _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cmpge(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cmpge(uint32_t _a, uint32_t _b)
 	{
 		return -(_a >= _b);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_setnz(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_setnz(uint32_t _a)
 	{
 		return -!!_a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_satadd(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_satadd(uint32_t _a, uint32_t _b)
 	{
 		const uint32_t add    = uint32_add(_a, _b);
 		const uint32_t lt     = uint32_cmplt(add, _a);
@@ -193,7 +193,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_satsub(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_satsub(uint32_t _a, uint32_t _b)
 	{
 		const uint32_t sub    = uint32_sub(_a, _b);
 		const uint32_t le     = uint32_cmple(sub, _a);
@@ -202,7 +202,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_satmul(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_satmul(uint32_t _a, uint32_t _b)
 	{
 		const uint64_t mul    = (uint64_t)_a * (uint64_t)_b;
 		const uint32_t hi     = mul >> 32;
@@ -212,7 +212,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_sels(uint32_t test, uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_sels(uint32_t test, uint32_t _a, uint32_t _b)
 	{
 		const uint32_t mask   = uint32_ext(test);
 		const uint32_t sel_a  = uint32_and(_a, mask);
@@ -222,7 +222,7 @@ namespace bx
 		return (result);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_selb(uint32_t _mask, uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_selb(uint32_t _mask, uint32_t _a, uint32_t _b)
 	{
 		const uint32_t sel_a  = uint32_and(_a, _mask);
 		const uint32_t sel_b  = uint32_andc(_b, _mask);
@@ -231,7 +231,7 @@ namespace bx
 		return (result);
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_imin(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_imin(uint32_t _a, uint32_t _b)
 	{
 		const uint32_t a_sub_b = uint32_sub(_a, _b);
 		const uint32_t result  = uint32_sels(a_sub_b, _a, _b);
@@ -239,7 +239,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_imax(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_imax(uint32_t _a, uint32_t _b)
 	{
 		const uint32_t b_sub_a = uint32_sub(_b, _a);
 		const uint32_t result  = uint32_sels(b_sub_a, _a, _b);
@@ -247,27 +247,27 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b)
 	{
 		return _a > _b ? _b : _a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b, uint32_t _c)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b, uint32_t _c)
 	{
 		return uint32_min(_a, uint32_min(_b, _c) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b)
 	{
 		return _a > _b ? _a : _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b, uint32_t _c)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b, uint32_t _c)
 	{
 		return uint32_max(_a, uint32_max(_b, _c) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_clamp(uint32_t _a, uint32_t _min, uint32_t _max)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_clamp(uint32_t _a, uint32_t _min, uint32_t _max)
 	{
 		const uint32_t tmp    = uint32_max(_a, _min);
 		const uint32_t result = uint32_min(tmp, _max);
@@ -275,7 +275,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_iclamp(uint32_t _a, uint32_t _min, uint32_t _max)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_iclamp(uint32_t _a, uint32_t _min, uint32_t _max)
 	{
 		const uint32_t tmp    = uint32_imax(_a, _min);
 		const uint32_t result = uint32_imin(tmp, _max);
@@ -283,7 +283,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_incwrap(uint32_t _val, uint32_t _min, uint32_t _max)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_incwrap(uint32_t _val, uint32_t _min, uint32_t _max)
 	{
 		const uint32_t inc          = uint32_inc(_val);
 		const uint32_t max_diff     = uint32_sub(_max, _val);
@@ -295,7 +295,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_decwrap(uint32_t _val, uint32_t _min, uint32_t _max)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_decwrap(uint32_t _val, uint32_t _min, uint32_t _max)
 	{
 		const uint32_t dec          = uint32_dec(_val);
 		const uint32_t min_diff     = uint32_sub(_min, _val);
@@ -307,7 +307,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cntbits(uint32_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cntbits(uint32_t _val)
 	{
 		const uint32_t tmp0   = uint32_srl(_val, 1);
 		const uint32_t tmp1   = uint32_and(tmp0, 0x55555555);
@@ -330,7 +330,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cntlz(uint32_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cntlz(uint32_t _val)
 	{
 		const uint32_t tmp0   = uint32_srl(_val, 1);
 		const uint32_t tmp1   = uint32_or(tmp0, _val);
@@ -348,7 +348,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_cnttz(uint32_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_cnttz(uint32_t _val)
 	{
 		const uint32_t tmp0   = uint32_not(_val);
 		const uint32_t tmp1   = uint32_dec(_val);
@@ -358,7 +358,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_part1by1(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_part1by1(uint32_t _a)
 	{
 		// shuffle:
 		// ---- ---- ---- ---- fedc ba98 7654 3210
@@ -386,7 +386,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_part1by2(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_part1by2(uint32_t _a)
 	{
 		// shuffle:
 		// ---- ---- ---- ---- ---- --98 7654 3210
@@ -414,7 +414,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_testpow2(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_testpow2(uint32_t _a)
 	{
 		const uint32_t tmp0   = uint32_dec(_a);
 		const uint32_t tmp1   = uint32_xor(_a, tmp0);
@@ -424,7 +424,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_nextpow2(uint32_t _a)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_nextpow2(uint32_t _a)
 	{
 		const uint32_t tmp0   = uint32_dec(_a);
 		const uint32_t tmp1   = uint32_srl(tmp0, 1);
@@ -442,7 +442,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint64_cntbits(uint64_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint64_cntbits(uint64_t _val)
 	{
 		const uint32_t lo = uint32_t(_val&UINT32_MAX);
 		const uint32_t hi = uint32_t(_val>>32);
@@ -452,7 +452,7 @@ namespace bx
 		return total;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint64_cntlz(uint64_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint64_cntlz(uint64_t _val)
 	{
 		return _val & UINT64_C(0xffffffff00000000)
 			 ? uint32_cntlz(uint32_t(_val>>32) )
@@ -460,7 +460,7 @@ namespace bx
 			 ;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint64_cnttz(uint64_t _val)
+	inline BX_CONSTEXPR_FUNC uint32_t uint64_cnttz(uint64_t _val)
 	{
 		return _val & UINT64_C(0xffffffff)
 			? uint32_cnttz(uint32_t(_val) )
@@ -468,47 +468,47 @@ namespace bx
 			;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_sll(uint64_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_sll(uint64_t _a, int32_t _sa)
 	{
 		return _a << _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_srl(uint64_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_srl(uint64_t _a, int32_t _sa)
 	{
 		return _a >> _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_sra(uint64_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_sra(uint64_t _a, int32_t _sa)
 	{
 		return ( (int64_t)_a) >> _sa;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_rol(uint64_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_rol(uint64_t _a, int32_t _sa)
 	{
 		return ( _a << _sa) | (_a >> (64-_sa) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_ror(uint64_t _a, int32_t _sa)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_ror(uint64_t _a, int32_t _sa)
 	{
 		return ( _a >> _sa) | (_a << (64-_sa) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_add(uint64_t _a, uint64_t _b)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_add(uint64_t _a, uint64_t _b)
 	{
 		return _a + _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_sub(uint64_t _a, uint64_t _b)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_sub(uint64_t _a, uint64_t _b)
 	{
 		return _a - _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint64_t uint64_mul(uint64_t _a, uint64_t _b)
+	inline BX_CONSTEXPR_FUNC uint64_t uint64_mul(uint64_t _a, uint64_t _b)
 	{
 		return _a * _b;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_gcd(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_gcd(uint32_t _a, uint32_t _b)
 	{
 		do
 		{
@@ -521,12 +521,12 @@ namespace bx
 		return _a;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t uint32_lcm(uint32_t _a, uint32_t _b)
+	inline BX_CONSTEXPR_FUNC uint32_t uint32_lcm(uint32_t _a, uint32_t _b)
 	{
 		return _a * (_b / uint32_gcd(_a, _b) );
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t strideAlign(uint32_t _offset, uint32_t _stride)
+	inline BX_CONSTEXPR_FUNC uint32_t strideAlign(uint32_t _offset, uint32_t _stride)
 	{
 		const uint32_t mod    = uint32_mod(_offset, _stride);
 		const uint32_t add    = uint32_sub(_stride, mod);
@@ -537,7 +537,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t strideAlign16(uint32_t _offset, uint32_t _stride)
+	inline BX_CONSTEXPR_FUNC uint32_t strideAlign16(uint32_t _offset, uint32_t _stride)
 	{
 		const uint32_t align  = uint32_lcm(16, _stride);
 		const uint32_t mod    = uint32_mod(_offset, align);
@@ -549,7 +549,7 @@ namespace bx
 		return result;
 	}
 
-	inline constexpr BX_CONST_FUNC uint32_t strideAlign256(uint32_t _offset, uint32_t _stride)
+	inline BX_CONSTEXPR_FUNC uint32_t strideAlign256(uint32_t _offset, uint32_t _stride)
 	{
 		const uint32_t align  = uint32_lcm(256, _stride);
 		const uint32_t mod    = uint32_mod(_offset, align);

include/bx/macros.h

@@ -46,6 +46,7 @@
 #define BX_ALIGN_256(_value) BX_ALIGN_MASK(_value, 0xff)
 #define BX_ALIGN_4096(_value) BX_ALIGN_MASK(_value, 0xfff)
 
+///
 #define BX_ALIGNOF(_type) __alignof(_type)
 
 #if defined(__has_feature)
@@ -112,6 +113,11 @@
 #	error "Unknown BX_COMPILER_?"
 #endif
 
+/// The return value of the function is solely a function of the arguments.
+///
+#define BX_CONSTEXPR_FUNC constexpr BX_CONST_FUNC
+
+///
 #define BX_STATIC_ASSERT(_condition, ...) static_assert(_condition, "" __VA_ARGS__)
 
 ///
@@ -199,19 +205,19 @@
 
 ///
 #define BX_CLASS_NO_DEFAULT_CTOR(_class) \
-			private: _class()
+	private: _class()
 
 #define BX_CLASS_NO_COPY(_class) \
-			private: _class(const _class& _rhs)
+	private: _class(const _class& _rhs)
 
 #define BX_CLASS_NO_ASSIGNMENT(_class) \
-			private: _class& operator=(const _class& _rhs)
+	private: _class& operator=(const _class& _rhs)
 
-#define BX_CLASS_ALLOCATOR(_class) \
-			public: void* operator new(size_t _size); \
-			public: void  operator delete(void* _ptr); \
-			public: void* operator new[](size_t _size); \
-			public: void  operator delete[](void* _ptr)
+#define BX_CLASS_ALLOCATOR(_class)              \
+	public: void* operator new(size_t _size);   \
+	public: void  operator delete(void* _ptr);  \
+	public: void* operator new[](size_t _size); \
+	public: void  operator delete[](void* _ptr)
 
 #define BX_CLASS_1(_class, _a1) BX_CONCATENATE(BX_CLASS_, _a1)(_class)
 #define BX_CLASS_2(_class, _a1, _a2) BX_CLASS_1(_class, _a1); BX_CLASS_1(_class, _a2)

include/bx/math.h

@@ -124,19 +124,19 @@ namespace bx
 
 	/// Returns linear interpolation between two values _a and _b.
 	///
-	constexpr BX_CONST_FUNC float lerp(float _a, float _b, float _t);
+	BX_CONSTEXPR_FUNC float lerp(float _a, float _b, float _t);
 
 	/// Returns the sign of _a.
 	///
-	constexpr BX_CONST_FUNC float sign(float _a);
+	BX_CONSTEXPR_FUNC float sign(float _a);
 
 	/// Returns the absolute of _a.
 	///
-	constexpr BX_CONST_FUNC float abs(float _a);
+	BX_CONSTEXPR_FUNC float abs(float _a);
 
 	/// Returns the square of _a.
 	///
-	constexpr BX_CONST_FUNC float square(float _a);
+	BX_CONSTEXPR_FUNC float square(float _a);
 
 	/// Returns the cosine of the argument _a.
 	///
@@ -217,23 +217,23 @@ namespace bx
 
 	/// Returns the nearest integer not greater in magnitude than _a.
 	///
-	constexpr BX_CONST_FUNC float trunc(float _a);
+	BX_CONSTEXPR_FUNC float trunc(float _a);
 
 	/// Returns the fractional (or decimal) part of _a, which is greater than or equal to 0
 	/// and less than 1.
 	///
-	constexpr BX_CONST_FUNC float fract(float _a);
+	BX_CONSTEXPR_FUNC float fract(float _a);
 
 	/// Returns result of multipla and add (_a * _b + _c).
 	///
-	constexpr BX_CONST_FUNC float mad(float _a, float _b, float _c);
+	BX_CONSTEXPR_FUNC float mad(float _a, float _b, float _c);
 
 	/// Returns the floating-point remainder of the division operation _a/_b.
 	///
 	BX_CONST_FUNC float mod(float _a, float _b);
 
 	///
-	constexpr BX_CONST_FUNC bool equal(float _a, float _b, float _epsilon);
+	BX_CONSTEXPR_FUNC bool equal(float _a, float _b, float _epsilon);
 
 	///
 	BX_CONST_FUNC bool equal(const float* _a, const float* _b, uint32_t _num, float _epsilon);
@@ -242,19 +242,19 @@ namespace bx
 	BX_CONST_FUNC float wrap(float _a, float _wrap);
 
 	///
-	constexpr BX_CONST_FUNC float step(float _edge, float _a);
+	BX_CONSTEXPR_FUNC float step(float _edge, float _a);
 
 	///
-	constexpr BX_CONST_FUNC float pulse(float _a, float _start, float _end);
+	BX_CONSTEXPR_FUNC float pulse(float _a, float _start, float _end);
 
 	///
-	constexpr BX_CONST_FUNC float smoothStep(float _a);
+	BX_CONSTEXPR_FUNC float smoothStep(float _a);
 
 	///
-	constexpr BX_CONST_FUNC float bias(float _time, float _bias);
+	BX_CONSTEXPR_FUNC float bias(float _time, float _bias);
 
 	///
-	constexpr BX_CONST_FUNC float gain(float _time, float _gain);
+	BX_CONSTEXPR_FUNC float gain(float _time, float _gain);
 
 	///
 	BX_CONST_FUNC float angleDiff(float _a, float _b);
@@ -270,58 +270,58 @@ namespace bx
 	void store(void* _ptr, const Vec3& _a);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 abs(const Vec3&  _a);
+	BX_CONSTEXPR_FUNC Vec3 abs(const Vec3&  _a);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 neg(const Vec3&  _a);
+	BX_CONSTEXPR_FUNC Vec3 neg(const Vec3&  _a);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 add(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 add(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 add(const Vec3&  _a, float _b);
+	BX_CONSTEXPR_FUNC Vec3 add(const Vec3&  _a, float _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 sub(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 sub(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 sub(const Vec3&  _a, float _b);
+	BX_CONSTEXPR_FUNC Vec3 sub(const Vec3&  _a, float _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 mul(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 mul(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 mul(const Vec3&  _a, float _b);
+	BX_CONSTEXPR_FUNC Vec3 mul(const Vec3&  _a, float _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 mad(const Vec3& _a, const Vec3& _b, const Vec3& _c);
+	BX_CONSTEXPR_FUNC Vec3 mad(const Vec3& _a, const Vec3& _b, const Vec3& _c);
 
 	///
-	constexpr BX_CONST_FUNC float dot(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC float dot(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 cross(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 cross(const Vec3&  _a, const Vec3&  _b);
 
 	///
 	BX_CONST_FUNC float length(const Vec3&  _a);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, float _t);
+	BX_CONSTEXPR_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, float _t);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, const Vec3&  _t);
+	BX_CONSTEXPR_FUNC Vec3 lerp(const Vec3&  _a, const Vec3&  _b, const Vec3&  _t);
 
 	///
 	BX_CONST_FUNC Vec3 normalize(const Vec3&  _a);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 min(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 min(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 max(const Vec3&  _a, const Vec3&  _b);
+	BX_CONSTEXPR_FUNC Vec3 max(const Vec3&  _a, const Vec3&  _b);
 
 	///
-	constexpr BX_CONST_FUNC Vec3 rcp(const Vec3&  _a);
+	BX_CONSTEXPR_FUNC Vec3 rcp(const Vec3&  _a);
 
 	///
 	void calcTangentFrame(Vec3& _outT, Vec3& _outB, const Vec3& _n);

include/bx/uint32_t.h

@@ -16,214 +16,214 @@ namespace bx
 	constexpr uint16_t kHalfFloatTwo  = UINT16_C(0x4000);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_li(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_li(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_dec(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_dec(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_inc(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_inc(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_not(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_not(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_neg(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_neg(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_ext(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_ext(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_and(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_and(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_andc(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_andc(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_xor(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_xor(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_xorl(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_xorl(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_or(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_or(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_orc(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_orc(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_sll(uint32_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint32_t uint32_sll(uint32_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_srl(uint32_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint32_t uint32_srl(uint32_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_sra(uint32_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint32_t uint32_sra(uint32_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_rol(uint32_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint32_t uint32_rol(uint32_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_ror(uint32_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint32_t uint32_ror(uint32_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_add(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_add(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_sub(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_sub(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_mul(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_mul(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_div(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_div(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_mod(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_mod(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmpeq(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmpeq(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmpneq(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmpneq(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmplt(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmplt(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmple(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmple(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmpgt(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmpgt(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cmpge(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cmpge(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_setnz(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_setnz(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_satadd(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_satadd(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_satsub(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_satsub(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_satmul(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_satmul(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_sels(uint32_t test, uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_sels(uint32_t test, uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_selb(uint32_t _mask, uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_selb(uint32_t _mask, uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_imin(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_imin(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_imax(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_imax(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b, uint32_t _c);
+	BX_CONSTEXPR_FUNC uint32_t uint32_min(uint32_t _a, uint32_t _b, uint32_t _c);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b, uint32_t _c);
+	BX_CONSTEXPR_FUNC uint32_t uint32_max(uint32_t _a, uint32_t _b, uint32_t _c);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_clamp(uint32_t _a, uint32_t _min, uint32_t _max);
+	BX_CONSTEXPR_FUNC uint32_t uint32_clamp(uint32_t _a, uint32_t _min, uint32_t _max);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_iclamp(uint32_t _a, uint32_t _min, uint32_t _max);
+	BX_CONSTEXPR_FUNC uint32_t uint32_iclamp(uint32_t _a, uint32_t _min, uint32_t _max);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_incwrap(uint32_t _val, uint32_t _min, uint32_t _max);
+	BX_CONSTEXPR_FUNC uint32_t uint32_incwrap(uint32_t _val, uint32_t _min, uint32_t _max);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_decwrap(uint32_t _val, uint32_t _min, uint32_t _max);
+	BX_CONSTEXPR_FUNC uint32_t uint32_decwrap(uint32_t _val, uint32_t _min, uint32_t _max);
 
 	/// Count number of bits set.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cntbits(uint32_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cntbits(uint32_t _val);
 
 	/// Count number of leading zeros.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cntlz(uint32_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cntlz(uint32_t _val);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_cnttz(uint32_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint32_cnttz(uint32_t _val);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_part1by1(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_part1by1(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_part1by2(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_part1by2(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_testpow2(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_testpow2(uint32_t _a);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_nextpow2(uint32_t _a);
+	BX_CONSTEXPR_FUNC uint32_t uint32_nextpow2(uint32_t _a);
 
 	/// Count number of bits set.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint64_cntbits(uint64_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint64_cntbits(uint64_t _val);
 
 	/// Count number of leading zeros.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint64_cntlz(uint64_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint64_cntlz(uint64_t _val);
 
 	///
-	constexpr BX_CONST_FUNC uint32_t uint64_cnttz(uint64_t _val);
+	BX_CONSTEXPR_FUNC uint32_t uint64_cnttz(uint64_t _val);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_sll(uint64_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint64_t uint64_sll(uint64_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_srl(uint64_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint64_t uint64_srl(uint64_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_sra(uint64_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint64_t uint64_sra(uint64_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_rol(uint64_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint64_t uint64_rol(uint64_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_ror(uint64_t _a, int32_t _sa);
+	BX_CONSTEXPR_FUNC uint64_t uint64_ror(uint64_t _a, int32_t _sa);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_add(uint64_t _a, uint64_t _b);
+	BX_CONSTEXPR_FUNC uint64_t uint64_add(uint64_t _a, uint64_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_sub(uint64_t _a, uint64_t _b);
+	BX_CONSTEXPR_FUNC uint64_t uint64_sub(uint64_t _a, uint64_t _b);
 
 	///
-	constexpr BX_CONST_FUNC uint64_t uint64_mul(uint64_t _a, uint64_t _b);
+	BX_CONSTEXPR_FUNC uint64_t uint64_mul(uint64_t _a, uint64_t _b);
 
 	/// Greatest common divisor.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_gcd(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_gcd(uint32_t _a, uint32_t _b);
 
 	/// Least common multiple.
 	///
-	constexpr BX_CONST_FUNC uint32_t uint32_lcm(uint32_t _a, uint32_t _b);
+	BX_CONSTEXPR_FUNC uint32_t uint32_lcm(uint32_t _a, uint32_t _b);
 
 	/// Align to arbitrary stride.
 	///
-	constexpr BX_CONST_FUNC uint32_t strideAlign(uint32_t _offset, uint32_t _stride);
+	BX_CONSTEXPR_FUNC uint32_t strideAlign(uint32_t _offset, uint32_t _stride);
 
 	/// Align to arbitrary stride and 16-bytes.
 	///
-	constexpr BX_CONST_FUNC uint32_t strideAlign16(uint32_t _offset, uint32_t _stride);
+	BX_CONSTEXPR_FUNC uint32_t strideAlign16(uint32_t _offset, uint32_t _stride);
 
 	/// Align to arbitrary stride and 256-bytes.
 	///
-	constexpr BX_CONST_FUNC uint32_t strideAlign256(uint32_t _offset, uint32_t _stride);
+	BX_CONSTEXPR_FUNC uint32_t strideAlign256(uint32_t _offset, uint32_t _stride);
 
 	/// Convert float to half-float.
 	///