Cleanup.

include/bx/float4_neon.h

@@ -19,7 +19,7 @@ namespace bx
 #define ELEMz 2
 #define ELEMw 3
 #define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
-			BX_FLOAT4_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
+			BX_FLOAT4_FORCE_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
 			{ \
 				return __builtin_shuffle(_a, (_u32x4_t){ ELEM##_x, ELEM##_y, ELEM##_z, ELEM##_w }); \
 			}
@@ -33,8 +33,8 @@ namespace bx
 #undef ELEMx
 
 #define IMPLEMENT_TEST(_xyzw, _swizzle) \
-			BX_FLOAT4_INLINE bool float4_test_any_##_xyzw(float4_t _test); \
-			BX_FLOAT4_INLINE bool float4_test_all_##_xyzw(float4_t _test);
+			BX_FLOAT4_FORCE_INLINE bool float4_test_any_##_xyzw(float4_t _test); \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_all_##_xyzw(float4_t _test);
 
 IMPLEMENT_TEST(x    , xxxx);
 IMPLEMENT_TEST(y    , yyyy);
@@ -54,93 +54,93 @@ IMPLEMENT_TEST(xyzw , xyzw);
 
 #undef IMPLEMENT_TEST
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 0, 1, 4, 5 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 4, 5, 0, 1 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 6, 7, 2, 3 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 2, 3, 6, 7 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 0, 4, 1, 5 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 1, 5, 0, 4 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 2, 6, 3, 7 });
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
 	{
 		return __builtin_shuffle(_a, _b, (_u32x4_t){ 6, 2, 7, 3 });
 	}
 
-	BX_FLOAT4_INLINE float float4_x(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_x(float4_t _a)
 	{
 		return __builtin_neon_vget_lanev4sf(_a, 0, 3);
 	}
 
-	BX_FLOAT4_INLINE float float4_y(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_y(float4_t _a)
 	{
 		return __builtin_neon_vget_lanev4sf(_a, 1, 3);
 	}
 
-	BX_FLOAT4_INLINE float float4_z(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_z(float4_t _a)
 	{
 		return __builtin_neon_vget_lanev4sf(_a, 2, 3);
 	}
 
-	BX_FLOAT4_INLINE float float4_w(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_w(float4_t _a)
 	{
 		return __builtin_neon_vget_lanev4sf(_a, 3, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(const void* _ptr)
 	{
 		return __builtin_neon_vld1v4sf( (const __builtin_neon_sf*)_ptr);
 	}
 
-	BX_FLOAT4_INLINE void float4_st(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_st(void* _ptr, float4_t _a)
 	{
 		__builtin_neon_vst1v4sf( (__builtin_neon_sf*)_ptr, _a);
 	}
 
-	BX_FLOAT4_INLINE void float4_stx(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stx(void* _ptr, float4_t _a)
 	{
 		__builtin_neon_vst1_lanev4sf( (__builtin_neon_sf*)_ptr, _a, 0); 
 	}
 
-	BX_FLOAT4_INLINE void float4_stream(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stream(void* _ptr, float4_t _a)
 	{
 		__builtin_neon_vst1v4sf( (__builtin_neon_sf*)_ptr, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
 	{
 		const float4_t val[4] = {_x, _y, _z, _w};
 		return float4_ld(val);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
 	{
 		const uint32_t val[4] = {_x, _y, _z, _w};
 		const _i32x4_t tmp    = __builtin_neon_vld1v4si( (const __builtin_neon_si*)val);
@@ -149,7 +149,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(const void* _ptr)
 	{
 		const float4_t tmp0   = __builtin_neon_vld1v4sf( (const __builtin_neon_sf *)_ptr);
 		const _f32x2_t tmp1   = __builtin_neon_vget_lowv4sf(tmp0);
@@ -158,12 +158,12 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(float _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(float _a)
 	{
 		return __builtin_neon_vdup_nv4sf(_a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isplat(uint32_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isplat(uint32_t _a)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vdup_nv4si( (__builtin_neon_si)_a);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -171,12 +171,12 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_zero()
+	BX_FLOAT4_FORCE_INLINE float4_t float4_zero()
 	{
 		return float4_isplat(0);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_itof(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_itof(float4_t _a)
 	{
 		const _i32x4_t itof   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const float4_t result = __builtin_neon_vcvtv4si(itof, 1);
@@ -184,7 +184,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ftoi(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ftoi(float4_t _a)
 	{
 		const _i32x4_t ftoi   = __builtin_neon_vcvtv4sf(_a, 1);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(ftoi);
@@ -192,32 +192,32 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_add(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_add(float4_t _a, float4_t _b)
 	{
 		return __builtin_neon_vaddv4sf(_a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
 	{
 		return __builtin_neon_vsubv4sf(_a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
 	{
 		return __builtin_neon_vmulv4sf(_a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rcp_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rcp_est(float4_t _a)
 	{
 		return __builtin_neon_vrecpev4sf(_a, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rsqrt_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rsqrt_est(float4_t _a)
 	{
 		return __builtin_neon_vrsqrtev4sf(_a, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vceqv4sf(_a, _b, 3);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -225,7 +225,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vcgtv4sf(_b, _a, 3);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -233,7 +233,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vcgev4sf(_b, _a, 3);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -241,7 +241,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vcgtv4sf(_a, _b, 3);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -249,7 +249,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp    = __builtin_neon_vcgev4sf(_a, _b, 3);
 		const float4_t result = __builtin_neon_vreinterpretv4sfv4si(tmp);
@@ -257,17 +257,17 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_min(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_min(float4_t _a, float4_t _b)
 	{
 		return __builtin_neon_vminv4sf(_a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_max(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_max(float4_t _a, float4_t _b)
 	{
 		return __builtin_neon_vmaxv4sf(_a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_and(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_and(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -277,7 +277,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -287,7 +287,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_or(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_or(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -297,7 +297,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -307,7 +307,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sll(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sll(float4_t _a, int _count)
 	{
 		if (__builtin_constant_p(_count) )
 		{
@@ -326,7 +326,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_srl(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_srl(float4_t _a, int _count)
 	{
 		if (__builtin_constant_p(_count) )
 		{
@@ -345,7 +345,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sra(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sra(float4_t _a, int _count)
 	{
 		if (__builtin_constant_p(_count) )
 		{
@@ -364,17 +364,17 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_madd(float4_t _a, float4_t _b, float4_t _c)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_madd(float4_t _a, float4_t _b, float4_t _c)
 	{
 		return __builtin_neon_vmlav4sf(_c, _a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_nmsub(float4_t _a, float4_t _b, float4_t _c)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_nmsub(float4_t _a, float4_t _b, float4_t _c)
 	{
 		return __builtin_neon_vmlsv4sf(_c, _a, _b, 3);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -384,7 +384,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -394,7 +394,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -404,7 +404,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -414,7 +414,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -424,7 +424,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -434,7 +434,7 @@ IMPLEMENT_TEST(xyzw , xyzw);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
 	{
 		const _i32x4_t tmp0   = __builtin_neon_vreinterpretv4siv4sf(_a);
 		const _i32x4_t tmp1   = __builtin_neon_vreinterpretv4siv4sf(_b);
@@ -482,13 +482,13 @@ IMPLEMENT_TEST(xyzw , xyzw);
 namespace bx
 {
 #define IMPLEMENT_TEST(_xyzw, _swizzle) \
-			BX_FLOAT4_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
 			{ \
 				const float4_t tmp0 = float4_swiz_##_swizzle(_test); \
 				return float4_test_any_ni(tmp0); \
 			} \
 			\
-			BX_FLOAT4_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
 			{ \
 				const float4_t tmp0 = float4_swiz_##_swizzle(_test); \
 				return float4_test_all_ni(tmp0); \
@@ -509,12 +509,12 @@ IMPLEMENT_TEST(zw   , zwww);
 IMPLEMENT_TEST(xzw  , xzww);
 IMPLEMENT_TEST(yzw  , yzww);
 
-	BX_FLOAT4_INLINE bool float4_test_any_xyzw(float4_t _test)
+	BX_FLOAT4_FORCE_INLINE bool float4_test_any_xyzw(float4_t _test)
 	{
 		return float4_test_any_ni(_test);
 	}
 
-	BX_FLOAT4_INLINE bool float4_test_all_xyzw(float4_t _test)
+	BX_FLOAT4_FORCE_INLINE bool float4_test_all_xyzw(float4_t _test)
 	{
 		return float4_test_all_ni(_test);
 	}

include/bx/float4_ref.h

@@ -12,9 +12,9 @@ namespace bx
 {
 	typedef union float4_t
 	{
+		float    fxyzw[4];
 		int32_t  ixyzw[4];
 		uint32_t uxyzw[4];
-		float    fxyzw[4];
 
 	} float4_t;
 
@@ -23,7 +23,7 @@ namespace bx
 #define ELEMz 2
 #define ELEMw 3
 #define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
-			BX_FLOAT4_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
+			BX_FLOAT4_FORCE_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
 			{ \
 				float4_t result; \
 				result.ixyzw[0] = _a.ixyzw[ELEM##_x]; \
@@ -42,7 +42,7 @@ namespace bx
 #undef ELEMx
 
 #define IMPLEMENT_TEST(_xyzw, _mask) \
-			BX_FLOAT4_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
 			{ \
 				uint32_t tmp = ( (_test.uxyzw[3]>>31)<<3) \
 				             | ( (_test.uxyzw[2]>>31)<<2) \
@@ -52,7 +52,7 @@ namespace bx
 				return 0 != (tmp&(_mask) ); \
 			} \
 			\
-			BX_FLOAT4_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
 			{ \
 				uint32_t tmp = ( (_test.uxyzw[3]>>31)<<3) \
 				             | ( (_test.uxyzw[2]>>31)<<2) \
@@ -80,7 +80,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 
 #undef IMPLEMENT_TEST
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0];
@@ -90,7 +90,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _b.uxyzw[0];
@@ -100,7 +100,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _b.uxyzw[2];
@@ -110,7 +110,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[2];
@@ -120,7 +120,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0];
@@ -130,7 +130,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[1];
@@ -140,7 +140,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[2];
@@ -150,7 +150,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _b.uxyzw[2];
@@ -160,27 +160,27 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float float4_x(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_x(float4_t _a)
 	{
 		return _a.fxyzw[0];
 	}
 
-	BX_FLOAT4_INLINE float float4_y(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_y(float4_t _a)
 	{
 		return _a.fxyzw[1];
 	}
 
-	BX_FLOAT4_INLINE float float4_z(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_z(float4_t _a)
 	{
 		return _a.fxyzw[2];
 	}
 
-	BX_FLOAT4_INLINE float float4_w(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_w(float4_t _a)
 	{
 		return _a.fxyzw[3];
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(const void* _ptr)
 	{
 		const uint32_t* input = reinterpret_cast<const uint32_t*>(_ptr);
 		float4_t result;
@@ -191,7 +191,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE void float4_st(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_st(void* _ptr, float4_t _a)
 	{
 		uint32_t* result = reinterpret_cast<uint32_t*>(_ptr);
 		result[0] = _a.uxyzw[0];
@@ -200,13 +200,13 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		result[3] = _a.uxyzw[3];
 	}
 
-	BX_FLOAT4_INLINE void float4_stx(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stx(void* _ptr, float4_t _a)
 	{
 		uint32_t* result = reinterpret_cast<uint32_t*>(_ptr);
 		result[0] = _a.uxyzw[0];
 	}
 
-	BX_FLOAT4_INLINE void float4_stream(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stream(void* _ptr, float4_t _a)
 	{
 		uint32_t* result = reinterpret_cast<uint32_t*>(_ptr);
 		result[0] = _a.uxyzw[0];
@@ -215,7 +215,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		result[3] = _a.uxyzw[3];
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
 	{
 		float4_t result;
 		result.fxyzw[0] = _x;
@@ -225,7 +225,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
 	{
 		float4_t result;
 		result.uxyzw[0] = _x;
@@ -235,7 +235,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(const void* _ptr)
 	{
 		const uint32_t val = *reinterpret_cast<const uint32_t*>(_ptr);
 		float4_t result;
@@ -246,22 +246,22 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(float _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(float _a)
 	{
 		return float4_ld(_a, _a, _a, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isplat(uint32_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isplat(uint32_t _a)
 	{
 		return float4_ild(_a, _a, _a, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_zero()
+	BX_FLOAT4_FORCE_INLINE float4_t float4_zero()
 	{
 		return float4_ild(0, 0, 0, 0);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_itof(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_itof(float4_t _a)
 	{
 		float4_t result;
 		result.fxyzw[0] = (float)_a.ixyzw[0];
@@ -271,7 +271,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ftoi(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ftoi(float4_t _a)
 	{
 		float4_t result;
 		result.ixyzw[0] = (int)_a.fxyzw[0];
@@ -281,7 +281,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_round(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_round(float4_t _a)
 	{
 		const float4_t tmp    = float4_ftoi(_a);
 		const float4_t result = float4_itof(tmp);
@@ -289,7 +289,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_add(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_add(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] + _b.fxyzw[0];
@@ -299,7 +299,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] - _b.fxyzw[0];
@@ -309,7 +309,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] * _b.fxyzw[0];
@@ -319,7 +319,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_div(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_div(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] / _b.fxyzw[0];
@@ -329,7 +329,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rcp_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rcp_est(float4_t _a)
 	{
 		float4_t result;
 		result.fxyzw[0] = 1.0f / _a.fxyzw[0];
@@ -339,7 +339,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sqrt(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sqrt(float4_t _a)
 	{
 		float4_t result;
 		result.fxyzw[0] = sqrtf(_a.fxyzw[0]);
@@ -349,7 +349,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rsqrt_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rsqrt_est(float4_t _a)
 	{
 		float4_t result;
 		result.fxyzw[0] = 1.0f / sqrtf(_a.fxyzw[0]);
@@ -359,7 +359,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.fxyzw[0] == _b.fxyzw[0] ? 0xffffffff : 0x0;
@@ -369,7 +369,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.fxyzw[0] < _b.fxyzw[0] ? 0xffffffff : 0x0;
@@ -379,7 +379,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.fxyzw[0] <= _b.fxyzw[0] ? 0xffffffff : 0x0;
@@ -389,7 +389,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.fxyzw[0] > _b.fxyzw[0] ? 0xffffffff : 0x0;
@@ -399,7 +399,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.fxyzw[0] >= _b.fxyzw[0] ? 0xffffffff : 0x0;
@@ -409,7 +409,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_min(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_min(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] < _b.fxyzw[0] ? _a.fxyzw[0] : _b.fxyzw[0];
@@ -419,7 +419,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_max(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_max(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.fxyzw[0] = _a.fxyzw[0] > _b.fxyzw[0] ? _a.fxyzw[0] : _b.fxyzw[0];
@@ -429,7 +429,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_and(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_and(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] & _b.uxyzw[0];
@@ -439,7 +439,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] & ~_b.uxyzw[0];
@@ -449,7 +449,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_or(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_or(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] | _b.uxyzw[0];
@@ -459,7 +459,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] ^ _b.uxyzw[0];
@@ -469,7 +469,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sll(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sll(float4_t _a, int _count)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] << _count;
@@ -479,7 +479,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_srl(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_srl(float4_t _a, int _count)
 	{
 		float4_t result;
 		result.uxyzw[0] = _a.uxyzw[0] >> _count;
@@ -489,7 +489,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sra(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sra(float4_t _a, int _count)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] >> _count;
@@ -499,7 +499,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] == _b.ixyzw[0] ? 0xffffffff : 0x0;
@@ -509,7 +509,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] < _b.ixyzw[0] ? 0xffffffff : 0x0;
@@ -519,7 +519,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] > _b.ixyzw[0] ? 0xffffffff : 0x0;
@@ -529,7 +529,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] < _b.ixyzw[0] ? _a.ixyzw[0] : _b.ixyzw[0];
@@ -539,7 +539,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] > _b.ixyzw[0] ? _a.ixyzw[0] : _b.ixyzw[0];
@@ -549,7 +549,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] + _b.ixyzw[0];
@@ -559,7 +559,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
 	{
 		float4_t result;
 		result.ixyzw[0] = _a.ixyzw[0] - _b.ixyzw[0];

include/bx/float4_sse.h

@@ -21,7 +21,7 @@ namespace bx
 #define ELEMz 2
 #define ELEMw 3
 #define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
-			BX_FLOAT4_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
+			BX_FLOAT4_FORCE_INLINE float4_t float4_swiz_##_x##_y##_z##_w(float4_t _a) \
 			{ \
 				return _mm_shuffle_ps( _a, _a, _MM_SHUFFLE(ELEM##_w, ELEM##_z, ELEM##_y, ELEM##_x ) ); \
 			}
@@ -35,12 +35,12 @@ namespace bx
 #undef ELEMx
 
 #define IMPLEMENT_TEST(_xyzw, _mask) \
-			BX_FLOAT4_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_any_##_xyzw(float4_t _test) \
 			{ \
 				return 0x0 != (_mm_movemask_ps(_test)&(_mask) ); \
 			} \
 			\
-			BX_FLOAT4_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
+			BX_FLOAT4_FORCE_INLINE bool float4_test_all_##_xyzw(float4_t _test) \
 			{ \
 				return (_mask) == (_mm_movemask_ps(_test)&(_mask) ); \
 			}
@@ -63,52 +63,52 @@ IMPLEMENT_TEST(xyzw , 0xf);
 
 #undef IMPLEMENT_TEST
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xyAB(float4_t _a, float4_t _b)
 	{
 		return _mm_movelh_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_ABxy(float4_t _a, float4_t _b)
 	{
 		return _mm_movelh_ps(_b, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CDzw(float4_t _a, float4_t _b)
 	{
 		return _mm_movehl_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zwCD(float4_t _a, float4_t _b)
 	{
 		return _mm_movehl_ps(_b, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_xAyB(float4_t _a, float4_t _b)
 	{
 		return _mm_unpacklo_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_yBxA(float4_t _a, float4_t _b)
 	{
 		return _mm_unpacklo_ps(_b, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_zCwD(float4_t _a, float4_t _b)
 	{
 		return _mm_unpackhi_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_shuf_CzDw(float4_t _a, float4_t _b)
 	{
 		return _mm_unpackhi_ps(_b, _a);
 	}
 
-	BX_FLOAT4_INLINE float float4_x(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_x(float4_t _a)
 	{
 		return _mm_cvtss_f32(_a);
 	}
 
-	BX_FLOAT4_INLINE float float4_y(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_y(float4_t _a)
 	{
 		const float4_t yyyy = float4_swiz_yyyy(_a);
 		const float result  = _mm_cvtss_f32(yyyy);
@@ -116,7 +116,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float float4_z(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_z(float4_t _a)
 	{
 		const float4_t zzzz = float4_swiz_zzzz(_a);
 		const float result  = _mm_cvtss_f32(zzzz);
@@ -124,7 +124,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float float4_w(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float float4_w(float4_t _a)
 	{
 		const float4_t wwww = float4_swiz_wwww(_a);
 		const float result  = _mm_cvtss_f32(wwww);
@@ -132,32 +132,32 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(const void* _ptr)
 	{
 		return _mm_load_ps(reinterpret_cast<const float*>(_ptr) );
 	}
 
-	BX_FLOAT4_INLINE void float4_st(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_st(void* _ptr, float4_t _a)
 	{
 		_mm_store_ps(reinterpret_cast<float*>(_ptr), _a);
 	}
 
-	BX_FLOAT4_INLINE void float4_stx(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stx(void* _ptr, float4_t _a)
 	{
 		_mm_store_ss(reinterpret_cast<float*>(_ptr), _a);
 	}
 
-	BX_FLOAT4_INLINE void float4_stream(void* _ptr, float4_t _a)
+	BX_FLOAT4_FORCE_INLINE void float4_stream(void* _ptr, float4_t _a)
 	{
 		_mm_stream_ps(reinterpret_cast<float*>(_ptr), _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ld(float _x, float _y, float _z, float _w)
 	{
 		return _mm_set_ps(_w, _z, _y, _x);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ild(uint32_t _x, uint32_t _y, uint32_t _z, uint32_t _w)
 	{
 		const __m128i set     = _mm_set_epi32(_w, _z, _y, _x);
 		const float4_t result = _mm_castsi128_ps(set);
@@ -165,7 +165,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(const void* _ptr)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(const void* _ptr)
 	{
 		const float4_t x___   = _mm_load_ss(reinterpret_cast<const float*>(_ptr) );
 		const float4_t result = float4_swiz_xxxx(x___);
@@ -173,12 +173,12 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_splat(float _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_splat(float _a)
 	{
 		return _mm_set1_ps(_a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isplat(uint32_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isplat(uint32_t _a)
 	{
 		const __m128i splat   = _mm_set1_epi32(_a);
 		const float4_t result = _mm_castsi128_ps(splat);
@@ -186,12 +186,12 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_zero()
+	BX_FLOAT4_FORCE_INLINE float4_t float4_zero()
 	{
 		return _mm_setzero_ps();
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_itof(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_itof(float4_t _a)
 	{
 		const __m128i  itof   = _mm_castps_si128(_a);
 		const float4_t result = _mm_cvtepi32_ps(itof);
@@ -199,7 +199,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_ftoi(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_ftoi(float4_t _a)
 	{
 		const __m128i ftoi    = _mm_cvtps_epi32(_a);
 		const float4_t result = _mm_castsi128_ps(ftoi);
@@ -207,7 +207,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_round(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_round(float4_t _a)
 	{
 #if defined(__SSE4_1__)
 		return _mm_round_ps(_a, _MM_FROUND_NINT);
@@ -219,109 +219,109 @@ IMPLEMENT_TEST(xyzw , 0xf);
 #endif // defined(__SSE4_1__)
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_add(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_add(float4_t _a, float4_t _b)
 	{
 		return _mm_add_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sub(float4_t _a, float4_t _b)
 	{
 		return _mm_sub_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_mul(float4_t _a, float4_t _b)
 	{
 		return _mm_mul_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_div(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_div(float4_t _a, float4_t _b)
 	{
 		return _mm_div_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rcp_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rcp_est(float4_t _a)
 	{
 		return _mm_rcp_ps(_a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sqrt(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sqrt(float4_t _a)
 	{
 		return _mm_sqrt_ps(_a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_rsqrt_est(float4_t _a)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_rsqrt_est(float4_t _a)
 	{
 		return _mm_rsqrt_ps(_a);
 	}
 
 #if defined(__SSE4_1__)
-	BX_FLOAT4_INLINE float4_t float4_dot3(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_dot3(float4_t _a, float4_t _b)
 	{
 		return _mm_dp_ps(_a, _b, 0x77);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_dot(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_dot(float4_t _a, float4_t _b)
 	{
 		return _mm_dp_ps(_a, _b, 0xFF);
 	}
 #endif // defined(__SSE4__)
 
-	BX_FLOAT4_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpeq(float4_t _a, float4_t _b)
 	{
 		return _mm_cmpeq_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmplt(float4_t _a, float4_t _b)
 	{
 		return _mm_cmplt_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmple(float4_t _a, float4_t _b)
 	{
 		return _mm_cmple_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpgt(float4_t _a, float4_t _b)
 	{
 		return _mm_cmpgt_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_cmpge(float4_t _a, float4_t _b)
 	{
 		return _mm_cmpge_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_min(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_min(float4_t _a, float4_t _b)
 	{
 		return _mm_min_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_max(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_max(float4_t _a, float4_t _b)
 	{
 		return _mm_max_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_and(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_and(float4_t _a, float4_t _b)
 	{
 		return _mm_and_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_andc(float4_t _a, float4_t _b)
 	{
 		return _mm_andnot_ps(_b, _a);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_or(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_or(float4_t _a, float4_t _b)
 	{
 		return _mm_or_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_xor(float4_t _a, float4_t _b)
 	{
 		return _mm_xor_ps(_a, _b);
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sll(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sll(float4_t _a, int _count)
 	{
 		const __m128i a       = _mm_castps_si128(_a);
 		const __m128i shift   = _mm_slli_epi32(a, _count);
@@ -330,7 +330,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_srl(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_srl(float4_t _a, int _count)
 	{
 		const __m128i a       = _mm_castps_si128(_a);
 		const __m128i shift   = _mm_srli_epi32(a, _count);
@@ -339,7 +339,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_sra(float4_t _a, int _count)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_sra(float4_t _a, int _count)
 	{
 		const __m128i a       = _mm_castps_si128(_a);
 		const __m128i shift   = _mm_srai_epi32(a, _count);
@@ -348,7 +348,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpeq(float4_t _a, float4_t _b)
 	{
 		const __m128i tmp0    = _mm_castps_si128(_a);
 		const __m128i tmp1    = _mm_castps_si128(_b);
@@ -358,7 +358,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmplt(float4_t _a, float4_t _b)
 	{
 		const __m128i tmp0    = _mm_castps_si128(_a);
 		const __m128i tmp1    = _mm_castps_si128(_b);
@@ -368,7 +368,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_icmpgt(float4_t _a, float4_t _b)
 	{
 		const __m128i tmp0    = _mm_castps_si128(_a);
 		const __m128i tmp1    = _mm_castps_si128(_b);
@@ -379,7 +379,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 	}
 
 #if defined(__SSE4_1__)
-	BX_FLOAT4_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imin(float4_t _a, float4_t _b)
 	{
 		const __m128i tmp0    = _mm_castps_si128(_a);
 		const __m128i tmp1    = _mm_castps_si128(_b);
@@ -389,7 +389,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_imax(float4_t _a, float4_t _b)
 	{
 		const __m128i tmp0    = _mm_castps_si128(_a);
 		const __m128i tmp1    = _mm_castps_si128(_b);
@@ -400,7 +400,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 	}
 #endif // defined(__SSE4_1__)
 
-	BX_FLOAT4_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_iadd(float4_t _a, float4_t _b)
 	{
 		const __m128i a       = _mm_castps_si128(_a);
 		const __m128i b       = _mm_castps_si128(_b);
@@ -410,7 +410,7 @@ IMPLEMENT_TEST(xyzw , 0xf);
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_isub(float4_t _a, float4_t _b)
 	{
 		const __m128i a       = _mm_castps_si128(_a);
 		const __m128i b       = _mm_castps_si128(_b);

include/bx/float4_t.h

@@ -8,7 +8,8 @@
 
 #include "bx.h"
 
-#define BX_FLOAT4_INLINE BX_FORCE_INLINE
+#define BX_FLOAT4_FORCE_INLINE BX_FORCE_INLINE
+#define BX_FLOAT4_INLINE static inline
 
 #if defined(__SSE2__) || (BX_COMPILER_MSVC && (BX_ARCH_64BIT || _M_IX86_FP >= 2) )
 #	include "float4_sse.h"

include/bx/float4x4_t.h

@@ -10,73 +10,66 @@
 
 namespace bx
 {
-	typedef BX_ALIGN_STRUCT_16(struct)
+	BX_ALIGN_STRUCT_16(struct) float4x4_t
 	{
 		float4_t col[4];
+	};
 
-	} float4x4_t;
-
-	BX_FLOAT4_INLINE float4_t float4_mul_xyz1(float4_t _a, const float4x4_t& _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_mul_xyz1(float4_t _a, const float4x4_t* _b)
 	{
 		const float4_t xxxx   = float4_swiz_xxxx(_a);
 		const float4_t yyyy   = float4_swiz_yyyy(_a);
 		const float4_t zzzz   = float4_swiz_zzzz(_a);
-		const float4_t col0   = float4_mul(_b.col[0], xxxx);
-		const float4_t col1   = float4_mul(_b.col[1], yyyy);
-		const float4_t col2   = float4_madd(_b.col[2], zzzz, col0);
-		const float4_t col3   = float4_add(_b.col[3], col1);
+		const float4_t col0   = float4_mul(_b->col[0], xxxx);
+		const float4_t col1   = float4_mul(_b->col[1], yyyy);
+		const float4_t col2   = float4_madd(_b->col[2], zzzz, col0);
+		const float4_t col3   = float4_add(_b->col[3], col1);
 		const float4_t result = float4_add(col2, col3);
 
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4_t float4_mul(float4_t _a, const float4x4_t& _b)
+	BX_FLOAT4_FORCE_INLINE float4_t float4_mul(float4_t _a, const float4x4_t* _b)
 	{
 		const float4_t xxxx   = float4_swiz_xxxx(_a);
 		const float4_t yyyy   = float4_swiz_yyyy(_a);
 		const float4_t zzzz   = float4_swiz_zzzz(_a);
 		const float4_t wwww   = float4_swiz_wwww(_a);
-		const float4_t col0   = float4_mul(_b.col[0], xxxx);
-		const float4_t col1   = float4_mul(_b.col[1], yyyy);
-		const float4_t col2   = float4_madd(_b.col[2], zzzz, col0);
-		const float4_t col3   = float4_madd(_b.col[3], wwww, col1);
+		const float4_t col0   = float4_mul(_b->col[0], xxxx);
+		const float4_t col1   = float4_mul(_b->col[1], yyyy);
+		const float4_t col2   = float4_madd(_b->col[2], zzzz, col0);
+		const float4_t col3   = float4_madd(_b->col[3], wwww, col1);
 		const float4_t result = float4_add(col2, col3);
 
 		return result;
 	}
 
-	BX_FLOAT4_INLINE float4x4_t float4x4_mul(const float4x4_t& _a, const float4x4_t& _b)
+	BX_FLOAT4_INLINE void float4x4_mul(float4x4_t* __restrict _result, const float4x4_t* __restrict _a, const float4x4_t* __restrict _b)
 	{
-		float4x4_t result;
-		result.col[0] = float4_mul(_a.col[0], _b);
-		result.col[1] = float4_mul(_a.col[1], _b);
-		result.col[2] = float4_mul(_a.col[2], _b);
-		result.col[3] = float4_mul(_a.col[3], _b);
-
-		return result;
+		_result->col[0] = float4_mul(_a->col[0], _b);
+		_result->col[1] = float4_mul(_a->col[1], _b);
+		_result->col[2] = float4_mul(_a->col[2], _b);
+		_result->col[3] = float4_mul(_a->col[3], _b);
 	}
 
-	BX_FLOAT4_INLINE float4x4_t float4x4_transpose(const float4x4_t& _mtx)
+	BX_FLOAT4_FORCE_INLINE void float4x4_transpose(float4x4_t* __restrict _result, const float4x4_t* __restrict _mtx)
 	{
-		const float4_t aibj = float4_shuf_xAyB(_mtx.col[0], _mtx.col[2]); // aibj
-		const float4_t emfn = float4_shuf_xAyB(_mtx.col[1], _mtx.col[3]); // emfn
-		const float4_t ckdl = float4_shuf_zCwD(_mtx.col[0], _mtx.col[2]); // ckdl
-		const float4_t gohp = float4_shuf_zCwD(_mtx.col[1], _mtx.col[3]); // gohp
-		float4x4_t result;
-		result.col[0] = float4_shuf_xAyB(aibj, emfn); // aeim
-		result.col[1] = float4_shuf_zCwD(aibj, emfn); // bfjn
-		result.col[2] = float4_shuf_xAyB(ckdl, gohp); // cgko
-		result.col[3] = float4_shuf_zCwD(ckdl, gohp); // dhlp
-
-		return result;
+		const float4_t aibj = float4_shuf_xAyB(_mtx->col[0], _mtx->col[2]); // aibj
+		const float4_t emfn = float4_shuf_xAyB(_mtx->col[1], _mtx->col[3]); // emfn
+		const float4_t ckdl = float4_shuf_zCwD(_mtx->col[0], _mtx->col[2]); // ckdl
+		const float4_t gohp = float4_shuf_zCwD(_mtx->col[1], _mtx->col[3]); // gohp
+		_result->col[0] = float4_shuf_xAyB(aibj, emfn); // aeim
+		_result->col[1] = float4_shuf_zCwD(aibj, emfn); // bfjn
+		_result->col[2] = float4_shuf_xAyB(ckdl, gohp); // cgko
+		_result->col[3] = float4_shuf_zCwD(ckdl, gohp); // dhlp
 	}
 
-	BX_FLOAT4_INLINE float4x4_t float4x4_inverse(const float4x4_t& _a)
+	BX_FLOAT4_INLINE void float4x4_inverse(float4x4_t* __restrict _result, const float4x4_t* __restrict _a)
 	{
-		const float4_t tmp0 = float4_shuf_xAzC(_a.col[0], _a.col[1]);
-		const float4_t tmp1 = float4_shuf_xAzC(_a.col[2], _a.col[3]);
-		const float4_t tmp2 = float4_shuf_yBwD(_a.col[0], _a.col[1]);
-		const float4_t tmp3 = float4_shuf_yBwD(_a.col[2], _a.col[3]);
+		const float4_t tmp0 = float4_shuf_xAzC(_a->col[0], _a->col[1]);
+		const float4_t tmp1 = float4_shuf_xAzC(_a->col[2], _a->col[3]);
+		const float4_t tmp2 = float4_shuf_yBwD(_a->col[0], _a->col[1]);
+		const float4_t tmp3 = float4_shuf_yBwD(_a->col[2], _a->col[3]);
 		const float4_t t0   = float4_shuf_xyAB(tmp0, tmp1);
 		const float4_t t1   = float4_shuf_xyAB(tmp3, tmp2);
 		const float4_t t2   = float4_shuf_zwCD(tmp0, tmp1);
@@ -154,13 +147,10 @@ namespace bx
 		const float4_t det    = float4_dot(t0, cof0);
 		const float4_t invdet = float4_rcp(det);
 
-		float4x4_t result;
-		result.col[0] = float4_mul(cof0, invdet);
-		result.col[1] = float4_mul(cof1, invdet);
-		result.col[2] = float4_mul(cof2, invdet);
-		result.col[3] = float4_mul(cof3, invdet);
-
-		return result;
+		_result->col[0] = float4_mul(cof0, invdet);
+		_result->col[1] = float4_mul(cof1, invdet);
+		_result->col[2] = float4_mul(cof2, invdet);
+		_result->col[3] = float4_mul(cof3, invdet);
 	}
 
 } // namespace bx