Cleanup.

include/bx/simd128_langext.inl

@@ -46,7 +46,7 @@ namespace bx
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			template<> \
 			BX_SIMD_FORCE_INLINE simd_langext_t float4_swiz_##_x##_y##_z##_w(simd_langext_t _a) \
 			{ \
@@ -57,13 +57,13 @@ namespace bx
 
 #include "float4_swizzle.inl"
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy
 #undef ELEMx
 
-#define IMPLEMENT_TEST(_xyzw, _mask) \
+#define BX_SIMD128_IMPLEMENT_TEST(_xyzw, _mask) \
 			template<> \
 			BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(simd_langext_t _test) \
 			{ \
@@ -86,23 +86,23 @@ namespace bx
 				return (_mask) == (tmp&(_mask) ); \
 			}
 
-IMPLEMENT_TEST(x    , 0x1);
-IMPLEMENT_TEST(y    , 0x2);
-IMPLEMENT_TEST(xy   , 0x3);
-IMPLEMENT_TEST(z    , 0x4);
-IMPLEMENT_TEST(xz   , 0x5);
-IMPLEMENT_TEST(yz   , 0x6);
-IMPLEMENT_TEST(xyz  , 0x7);
-IMPLEMENT_TEST(w    , 0x8);
-IMPLEMENT_TEST(xw   , 0x9);
-IMPLEMENT_TEST(yw   , 0xa);
-IMPLEMENT_TEST(xyw  , 0xb);
-IMPLEMENT_TEST(zw   , 0xc);
-IMPLEMENT_TEST(xzw  , 0xd);
-IMPLEMENT_TEST(yzw  , 0xe);
-IMPLEMENT_TEST(xyzw , 0xf);
-
-#undef IMPLEMENT_TEST
+BX_SIMD128_IMPLEMENT_TEST(x    , 0x1);
+BX_SIMD128_IMPLEMENT_TEST(y    , 0x2);
+BX_SIMD128_IMPLEMENT_TEST(xy   , 0x3);
+BX_SIMD128_IMPLEMENT_TEST(z    , 0x4);
+BX_SIMD128_IMPLEMENT_TEST(xz   , 0x5);
+BX_SIMD128_IMPLEMENT_TEST(yz   , 0x6);
+BX_SIMD128_IMPLEMENT_TEST(xyz  , 0x7);
+BX_SIMD128_IMPLEMENT_TEST(w    , 0x8);
+BX_SIMD128_IMPLEMENT_TEST(xw   , 0x9);
+BX_SIMD128_IMPLEMENT_TEST(yw   , 0xa);
+BX_SIMD128_IMPLEMENT_TEST(xyw  , 0xb);
+BX_SIMD128_IMPLEMENT_TEST(zw   , 0xc);
+BX_SIMD128_IMPLEMENT_TEST(xzw  , 0xd);
+BX_SIMD128_IMPLEMENT_TEST(yzw  , 0xe);
+BX_SIMD128_IMPLEMENT_TEST(xyzw , 0xf);
+
+#undef BX_SIMD128_IMPLEMENT_TEST
 
 	template<>
 	BX_SIMD_FORCE_INLINE simd_langext_t float4_shuf_xyAB(simd_langext_t _a, simd_langext_t _b)

include/bx/simd128_neon.inl

@@ -43,7 +43,7 @@ namespace bx
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			template<> \
 			BX_SIMD_FORCE_INLINE simd128_neon_t simd_swiz_##_x##_y##_z##_w(simd128_neon_t _a) \
 			{ \
@@ -52,13 +52,13 @@ namespace bx
 
 #include "simd_swizzle.inl"
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy
 #undef ELEMx
 
-#define IMPLEMENT_TEST(_xyzw, _swizzle) \
+#define BX_SIMD128_IMPLEMENT_TEST(_xyzw, _swizzle) \
 			template<> \
 			BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(simd128_neon_t _test) \
 			{ \
@@ -73,21 +73,21 @@ namespace bx
 				return simd_test_all_ni(tmp0); \
 			}
 
-IMPLEMENT_TEST(x,   xxxx);
-IMPLEMENT_TEST(y,   yyyy);
-IMPLEMENT_TEST(xy,  xyyy);
-IMPLEMENT_TEST(z,   zzzz);
-IMPLEMENT_TEST(xz,  xzzz);
-IMPLEMENT_TEST(yz,  yzzz);
-IMPLEMENT_TEST(xyz, xyzz);
-IMPLEMENT_TEST(w,   wwww);
-IMPLEMENT_TEST(xw,  xwww);
-IMPLEMENT_TEST(yw,  ywww);
-IMPLEMENT_TEST(xyw, xyww);
-IMPLEMENT_TEST(zw,  zwww);
-IMPLEMENT_TEST(xzw, xzww);
-IMPLEMENT_TEST(yzw, yzww);
-#undef IMPLEMENT_TEST
+BX_SIMD128_IMPLEMENT_TEST(x,   xxxx);
+BX_SIMD128_IMPLEMENT_TEST(y,   yyyy);
+BX_SIMD128_IMPLEMENT_TEST(xy,  xyyy);
+BX_SIMD128_IMPLEMENT_TEST(z,   zzzz);
+BX_SIMD128_IMPLEMENT_TEST(xz,  xzzz);
+BX_SIMD128_IMPLEMENT_TEST(yz,  yzzz);
+BX_SIMD128_IMPLEMENT_TEST(xyz, xyzz);
+BX_SIMD128_IMPLEMENT_TEST(w,   wwww);
+BX_SIMD128_IMPLEMENT_TEST(xw,  xwww);
+BX_SIMD128_IMPLEMENT_TEST(yw,  ywww);
+BX_SIMD128_IMPLEMENT_TEST(xyw, xyww);
+BX_SIMD128_IMPLEMENT_TEST(zw,  zwww);
+BX_SIMD128_IMPLEMENT_TEST(xzw, xzww);
+BX_SIMD128_IMPLEMENT_TEST(yzw, yzww);
+#undef BX_SIMD128_IMPLEMENT_TEST
 
 	template<>
 	BX_SIMD_FORCE_INLINE bool simd_test_any_xyzw(simd128_neon_t _test)

include/bx/simd128_ref.inl

@@ -45,7 +45,7 @@ namespace bx
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			template<> \
 			BX_SIMD_FORCE_INLINE simd128_ref_t simd_swiz_##_x##_y##_z##_w(simd128_ref_t _a) \
 			{ \
@@ -59,13 +59,13 @@ namespace bx
 
 #include "simd_swizzle.inl"
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy
 #undef ELEMx
 
-#define IMPLEMENT_TEST(_xyzw, _mask) \
+#define BX_SIMD128_IMPLEMENT_TEST(_xyzw, _mask) \
 			template<> \
 			BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(simd128_ref_t _test) \
 			{ \
@@ -88,23 +88,23 @@ namespace bx
 				return (_mask) == (tmp&(_mask) ); \
 			}
 
-IMPLEMENT_TEST(x    , 0x1);
-IMPLEMENT_TEST(y    , 0x2);
-IMPLEMENT_TEST(xy   , 0x3);
-IMPLEMENT_TEST(z    , 0x4);
-IMPLEMENT_TEST(xz   , 0x5);
-IMPLEMENT_TEST(yz   , 0x6);
-IMPLEMENT_TEST(xyz  , 0x7);
-IMPLEMENT_TEST(w    , 0x8);
-IMPLEMENT_TEST(xw   , 0x9);
-IMPLEMENT_TEST(yw   , 0xa);
-IMPLEMENT_TEST(xyw  , 0xb);
-IMPLEMENT_TEST(zw   , 0xc);
-IMPLEMENT_TEST(xzw  , 0xd);
-IMPLEMENT_TEST(yzw  , 0xe);
-IMPLEMENT_TEST(xyzw , 0xf);
-
-#undef IMPLEMENT_TEST
+BX_SIMD128_IMPLEMENT_TEST(x    , 0x1);
+BX_SIMD128_IMPLEMENT_TEST(y    , 0x2);
+BX_SIMD128_IMPLEMENT_TEST(xy   , 0x3);
+BX_SIMD128_IMPLEMENT_TEST(z    , 0x4);
+BX_SIMD128_IMPLEMENT_TEST(xz   , 0x5);
+BX_SIMD128_IMPLEMENT_TEST(yz   , 0x6);
+BX_SIMD128_IMPLEMENT_TEST(xyz  , 0x7);
+BX_SIMD128_IMPLEMENT_TEST(w    , 0x8);
+BX_SIMD128_IMPLEMENT_TEST(xw   , 0x9);
+BX_SIMD128_IMPLEMENT_TEST(yw   , 0xa);
+BX_SIMD128_IMPLEMENT_TEST(xyw  , 0xb);
+BX_SIMD128_IMPLEMENT_TEST(zw   , 0xc);
+BX_SIMD128_IMPLEMENT_TEST(xzw  , 0xd);
+BX_SIMD128_IMPLEMENT_TEST(yzw  , 0xe);
+BX_SIMD128_IMPLEMENT_TEST(xyzw , 0xf);
+
+#undef BX_SIMD128_IMPLEMENT_TEST
 
 	template<>
 	BX_SIMD_FORCE_INLINE simd128_ref_t simd_shuf_xyAB(simd128_ref_t _a, simd128_ref_t _b)

include/bx/simd128_sse.inl

@@ -14,7 +14,7 @@ namespace bx
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			template<> \
 			BX_SIMD_FORCE_INLINE simd128_sse_t simd_swiz_##_x##_y##_z##_w(simd128_sse_t _a) \
 			{ \
@@ -23,13 +23,13 @@ namespace bx
 
 #include "simd_swizzle.inl"
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy
 #undef ELEMx
 
-#define IMPLEMENT_TEST(_xyzw, _mask) \
+#define BX_SIMD128_IMPLEMENT_TEST(_xyzw, _mask) \
 			template<> \
 			BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(simd128_sse_t _test) \
 			{ \
@@ -42,23 +42,23 @@ namespace bx
 				return (_mask) == (_mm_movemask_ps(_test)&(_mask) ); \
 			}
 
-IMPLEMENT_TEST(x    , 0x1);
-IMPLEMENT_TEST(y    , 0x2);
-IMPLEMENT_TEST(xy   , 0x3);
-IMPLEMENT_TEST(z    , 0x4);
-IMPLEMENT_TEST(xz   , 0x5);
-IMPLEMENT_TEST(yz   , 0x6);
-IMPLEMENT_TEST(xyz  , 0x7);
-IMPLEMENT_TEST(w    , 0x8);
-IMPLEMENT_TEST(xw   , 0x9);
-IMPLEMENT_TEST(yw   , 0xa);
-IMPLEMENT_TEST(xyw  , 0xb);
-IMPLEMENT_TEST(zw   , 0xc);
-IMPLEMENT_TEST(xzw  , 0xd);
-IMPLEMENT_TEST(yzw  , 0xe);
-IMPLEMENT_TEST(xyzw , 0xf);
-
-#undef IMPLEMENT_TEST
+BX_SIMD128_IMPLEMENT_TEST(x    , 0x1);
+BX_SIMD128_IMPLEMENT_TEST(y    , 0x2);
+BX_SIMD128_IMPLEMENT_TEST(xy   , 0x3);
+BX_SIMD128_IMPLEMENT_TEST(z    , 0x4);
+BX_SIMD128_IMPLEMENT_TEST(xz   , 0x5);
+BX_SIMD128_IMPLEMENT_TEST(yz   , 0x6);
+BX_SIMD128_IMPLEMENT_TEST(xyz  , 0x7);
+BX_SIMD128_IMPLEMENT_TEST(w    , 0x8);
+BX_SIMD128_IMPLEMENT_TEST(xw   , 0x9);
+BX_SIMD128_IMPLEMENT_TEST(yw   , 0xa);
+BX_SIMD128_IMPLEMENT_TEST(xyw  , 0xb);
+BX_SIMD128_IMPLEMENT_TEST(zw   , 0xc);
+BX_SIMD128_IMPLEMENT_TEST(xzw  , 0xd);
+BX_SIMD128_IMPLEMENT_TEST(yzw  , 0xe);
+BX_SIMD128_IMPLEMENT_TEST(xyzw , 0xf);
+
+#undef BX_SIMD128_IMPLEMENT_TEST
 
 	template<>
 	BX_SIMD_FORCE_INLINE simd128_sse_t simd_shuf_xyAB(simd128_sse_t _a, simd128_sse_t _b)

include/bx/simd_swizzle.inl

@@ -8,259 +8,259 @@
 #endif // BX_FLOAT4_T_H_HEADER_GUARD
 
 // included from float4_t.h
-IMPLEMENT_SWIZZLE(x, x, x, x)
-IMPLEMENT_SWIZZLE(x, x, x, y)
-IMPLEMENT_SWIZZLE(x, x, x, z)
-IMPLEMENT_SWIZZLE(x, x, x, w)
-IMPLEMENT_SWIZZLE(x, x, y, x)
-IMPLEMENT_SWIZZLE(x, x, y, y)
-IMPLEMENT_SWIZZLE(x, x, y, z)
-IMPLEMENT_SWIZZLE(x, x, y, w)
-IMPLEMENT_SWIZZLE(x, x, z, x)
-IMPLEMENT_SWIZZLE(x, x, z, y)
-IMPLEMENT_SWIZZLE(x, x, z, z)
-IMPLEMENT_SWIZZLE(x, x, z, w)
-IMPLEMENT_SWIZZLE(x, x, w, x)
-IMPLEMENT_SWIZZLE(x, x, w, y)
-IMPLEMENT_SWIZZLE(x, x, w, z)
-IMPLEMENT_SWIZZLE(x, x, w, w)
-IMPLEMENT_SWIZZLE(x, y, x, x)
-IMPLEMENT_SWIZZLE(x, y, x, y)
-IMPLEMENT_SWIZZLE(x, y, x, z)
-IMPLEMENT_SWIZZLE(x, y, x, w)
-IMPLEMENT_SWIZZLE(x, y, y, x)
-IMPLEMENT_SWIZZLE(x, y, y, y)
-IMPLEMENT_SWIZZLE(x, y, y, z)
-IMPLEMENT_SWIZZLE(x, y, y, w)
-IMPLEMENT_SWIZZLE(x, y, z, x)
-IMPLEMENT_SWIZZLE(x, y, z, y)
-IMPLEMENT_SWIZZLE(x, y, z, z)
-// IMPLEMENT_SWIZZLE(x, y, z, w)
-IMPLEMENT_SWIZZLE(x, y, w, x)
-IMPLEMENT_SWIZZLE(x, y, w, y)
-IMPLEMENT_SWIZZLE(x, y, w, z)
-IMPLEMENT_SWIZZLE(x, y, w, w)
-IMPLEMENT_SWIZZLE(x, z, x, x)
-IMPLEMENT_SWIZZLE(x, z, x, y)
-IMPLEMENT_SWIZZLE(x, z, x, z)
-IMPLEMENT_SWIZZLE(x, z, x, w)
-IMPLEMENT_SWIZZLE(x, z, y, x)
-IMPLEMENT_SWIZZLE(x, z, y, y)
-IMPLEMENT_SWIZZLE(x, z, y, z)
-IMPLEMENT_SWIZZLE(x, z, y, w)
-IMPLEMENT_SWIZZLE(x, z, z, x)
-IMPLEMENT_SWIZZLE(x, z, z, y)
-IMPLEMENT_SWIZZLE(x, z, z, z)
-IMPLEMENT_SWIZZLE(x, z, z, w)
-IMPLEMENT_SWIZZLE(x, z, w, x)
-IMPLEMENT_SWIZZLE(x, z, w, y)
-IMPLEMENT_SWIZZLE(x, z, w, z)
-IMPLEMENT_SWIZZLE(x, z, w, w)
-IMPLEMENT_SWIZZLE(x, w, x, x)
-IMPLEMENT_SWIZZLE(x, w, x, y)
-IMPLEMENT_SWIZZLE(x, w, x, z)
-IMPLEMENT_SWIZZLE(x, w, x, w)
-IMPLEMENT_SWIZZLE(x, w, y, x)
-IMPLEMENT_SWIZZLE(x, w, y, y)
-IMPLEMENT_SWIZZLE(x, w, y, z)
-IMPLEMENT_SWIZZLE(x, w, y, w)
-IMPLEMENT_SWIZZLE(x, w, z, x)
-IMPLEMENT_SWIZZLE(x, w, z, y)
-IMPLEMENT_SWIZZLE(x, w, z, z)
-IMPLEMENT_SWIZZLE(x, w, z, w)
-IMPLEMENT_SWIZZLE(x, w, w, x)
-IMPLEMENT_SWIZZLE(x, w, w, y)
-IMPLEMENT_SWIZZLE(x, w, w, z)
-IMPLEMENT_SWIZZLE(x, w, w, w)
-IMPLEMENT_SWIZZLE(y, x, x, x)
-IMPLEMENT_SWIZZLE(y, x, x, y)
-IMPLEMENT_SWIZZLE(y, x, x, z)
-IMPLEMENT_SWIZZLE(y, x, x, w)
-IMPLEMENT_SWIZZLE(y, x, y, x)
-IMPLEMENT_SWIZZLE(y, x, y, y)
-IMPLEMENT_SWIZZLE(y, x, y, z)
-IMPLEMENT_SWIZZLE(y, x, y, w)
-IMPLEMENT_SWIZZLE(y, x, z, x)
-IMPLEMENT_SWIZZLE(y, x, z, y)
-IMPLEMENT_SWIZZLE(y, x, z, z)
-IMPLEMENT_SWIZZLE(y, x, z, w)
-IMPLEMENT_SWIZZLE(y, x, w, x)
-IMPLEMENT_SWIZZLE(y, x, w, y)
-IMPLEMENT_SWIZZLE(y, x, w, z)
-IMPLEMENT_SWIZZLE(y, x, w, w)
-IMPLEMENT_SWIZZLE(y, y, x, x)
-IMPLEMENT_SWIZZLE(y, y, x, y)
-IMPLEMENT_SWIZZLE(y, y, x, z)
-IMPLEMENT_SWIZZLE(y, y, x, w)
-IMPLEMENT_SWIZZLE(y, y, y, x)
-IMPLEMENT_SWIZZLE(y, y, y, y)
-IMPLEMENT_SWIZZLE(y, y, y, z)
-IMPLEMENT_SWIZZLE(y, y, y, w)
-IMPLEMENT_SWIZZLE(y, y, z, x)
-IMPLEMENT_SWIZZLE(y, y, z, y)
-IMPLEMENT_SWIZZLE(y, y, z, z)
-IMPLEMENT_SWIZZLE(y, y, z, w)
-IMPLEMENT_SWIZZLE(y, y, w, x)
-IMPLEMENT_SWIZZLE(y, y, w, y)
-IMPLEMENT_SWIZZLE(y, y, w, z)
-IMPLEMENT_SWIZZLE(y, y, w, w)
-IMPLEMENT_SWIZZLE(y, z, x, x)
-IMPLEMENT_SWIZZLE(y, z, x, y)
-IMPLEMENT_SWIZZLE(y, z, x, z)
-IMPLEMENT_SWIZZLE(y, z, x, w)
-IMPLEMENT_SWIZZLE(y, z, y, x)
-IMPLEMENT_SWIZZLE(y, z, y, y)
-IMPLEMENT_SWIZZLE(y, z, y, z)
-IMPLEMENT_SWIZZLE(y, z, y, w)
-IMPLEMENT_SWIZZLE(y, z, z, x)
-IMPLEMENT_SWIZZLE(y, z, z, y)
-IMPLEMENT_SWIZZLE(y, z, z, z)
-IMPLEMENT_SWIZZLE(y, z, z, w)
-IMPLEMENT_SWIZZLE(y, z, w, x)
-IMPLEMENT_SWIZZLE(y, z, w, y)
-IMPLEMENT_SWIZZLE(y, z, w, z)
-IMPLEMENT_SWIZZLE(y, z, w, w)
-IMPLEMENT_SWIZZLE(y, w, x, x)
-IMPLEMENT_SWIZZLE(y, w, x, y)
-IMPLEMENT_SWIZZLE(y, w, x, z)
-IMPLEMENT_SWIZZLE(y, w, x, w)
-IMPLEMENT_SWIZZLE(y, w, y, x)
-IMPLEMENT_SWIZZLE(y, w, y, y)
-IMPLEMENT_SWIZZLE(y, w, y, z)
-IMPLEMENT_SWIZZLE(y, w, y, w)
-IMPLEMENT_SWIZZLE(y, w, z, x)
-IMPLEMENT_SWIZZLE(y, w, z, y)
-IMPLEMENT_SWIZZLE(y, w, z, z)
-IMPLEMENT_SWIZZLE(y, w, z, w)
-IMPLEMENT_SWIZZLE(y, w, w, x)
-IMPLEMENT_SWIZZLE(y, w, w, y)
-IMPLEMENT_SWIZZLE(y, w, w, z)
-IMPLEMENT_SWIZZLE(y, w, w, w)
-IMPLEMENT_SWIZZLE(z, x, x, x)
-IMPLEMENT_SWIZZLE(z, x, x, y)
-IMPLEMENT_SWIZZLE(z, x, x, z)
-IMPLEMENT_SWIZZLE(z, x, x, w)
-IMPLEMENT_SWIZZLE(z, x, y, x)
-IMPLEMENT_SWIZZLE(z, x, y, y)
-IMPLEMENT_SWIZZLE(z, x, y, z)
-IMPLEMENT_SWIZZLE(z, x, y, w)
-IMPLEMENT_SWIZZLE(z, x, z, x)
-IMPLEMENT_SWIZZLE(z, x, z, y)
-IMPLEMENT_SWIZZLE(z, x, z, z)
-IMPLEMENT_SWIZZLE(z, x, z, w)
-IMPLEMENT_SWIZZLE(z, x, w, x)
-IMPLEMENT_SWIZZLE(z, x, w, y)
-IMPLEMENT_SWIZZLE(z, x, w, z)
-IMPLEMENT_SWIZZLE(z, x, w, w)
-IMPLEMENT_SWIZZLE(z, y, x, x)
-IMPLEMENT_SWIZZLE(z, y, x, y)
-IMPLEMENT_SWIZZLE(z, y, x, z)
-IMPLEMENT_SWIZZLE(z, y, x, w)
-IMPLEMENT_SWIZZLE(z, y, y, x)
-IMPLEMENT_SWIZZLE(z, y, y, y)
-IMPLEMENT_SWIZZLE(z, y, y, z)
-IMPLEMENT_SWIZZLE(z, y, y, w)
-IMPLEMENT_SWIZZLE(z, y, z, x)
-IMPLEMENT_SWIZZLE(z, y, z, y)
-IMPLEMENT_SWIZZLE(z, y, z, z)
-IMPLEMENT_SWIZZLE(z, y, z, w)
-IMPLEMENT_SWIZZLE(z, y, w, x)
-IMPLEMENT_SWIZZLE(z, y, w, y)
-IMPLEMENT_SWIZZLE(z, y, w, z)
-IMPLEMENT_SWIZZLE(z, y, w, w)
-IMPLEMENT_SWIZZLE(z, z, x, x)
-IMPLEMENT_SWIZZLE(z, z, x, y)
-IMPLEMENT_SWIZZLE(z, z, x, z)
-IMPLEMENT_SWIZZLE(z, z, x, w)
-IMPLEMENT_SWIZZLE(z, z, y, x)
-IMPLEMENT_SWIZZLE(z, z, y, y)
-IMPLEMENT_SWIZZLE(z, z, y, z)
-IMPLEMENT_SWIZZLE(z, z, y, w)
-IMPLEMENT_SWIZZLE(z, z, z, x)
-IMPLEMENT_SWIZZLE(z, z, z, y)
-IMPLEMENT_SWIZZLE(z, z, z, z)
-IMPLEMENT_SWIZZLE(z, z, z, w)
-IMPLEMENT_SWIZZLE(z, z, w, x)
-IMPLEMENT_SWIZZLE(z, z, w, y)
-IMPLEMENT_SWIZZLE(z, z, w, z)
-IMPLEMENT_SWIZZLE(z, z, w, w)
-IMPLEMENT_SWIZZLE(z, w, x, x)
-IMPLEMENT_SWIZZLE(z, w, x, y)
-IMPLEMENT_SWIZZLE(z, w, x, z)
-IMPLEMENT_SWIZZLE(z, w, x, w)
-IMPLEMENT_SWIZZLE(z, w, y, x)
-IMPLEMENT_SWIZZLE(z, w, y, y)
-IMPLEMENT_SWIZZLE(z, w, y, z)
-IMPLEMENT_SWIZZLE(z, w, y, w)
-IMPLEMENT_SWIZZLE(z, w, z, x)
-IMPLEMENT_SWIZZLE(z, w, z, y)
-IMPLEMENT_SWIZZLE(z, w, z, z)
-IMPLEMENT_SWIZZLE(z, w, z, w)
-IMPLEMENT_SWIZZLE(z, w, w, x)
-IMPLEMENT_SWIZZLE(z, w, w, y)
-IMPLEMENT_SWIZZLE(z, w, w, z)
-IMPLEMENT_SWIZZLE(z, w, w, w)
-IMPLEMENT_SWIZZLE(w, x, x, x)
-IMPLEMENT_SWIZZLE(w, x, x, y)
-IMPLEMENT_SWIZZLE(w, x, x, z)
-IMPLEMENT_SWIZZLE(w, x, x, w)
-IMPLEMENT_SWIZZLE(w, x, y, x)
-IMPLEMENT_SWIZZLE(w, x, y, y)
-IMPLEMENT_SWIZZLE(w, x, y, z)
-IMPLEMENT_SWIZZLE(w, x, y, w)
-IMPLEMENT_SWIZZLE(w, x, z, x)
-IMPLEMENT_SWIZZLE(w, x, z, y)
-IMPLEMENT_SWIZZLE(w, x, z, z)
-IMPLEMENT_SWIZZLE(w, x, z, w)
-IMPLEMENT_SWIZZLE(w, x, w, x)
-IMPLEMENT_SWIZZLE(w, x, w, y)
-IMPLEMENT_SWIZZLE(w, x, w, z)
-IMPLEMENT_SWIZZLE(w, x, w, w)
-IMPLEMENT_SWIZZLE(w, y, x, x)
-IMPLEMENT_SWIZZLE(w, y, x, y)
-IMPLEMENT_SWIZZLE(w, y, x, z)
-IMPLEMENT_SWIZZLE(w, y, x, w)
-IMPLEMENT_SWIZZLE(w, y, y, x)
-IMPLEMENT_SWIZZLE(w, y, y, y)
-IMPLEMENT_SWIZZLE(w, y, y, z)
-IMPLEMENT_SWIZZLE(w, y, y, w)
-IMPLEMENT_SWIZZLE(w, y, z, x)
-IMPLEMENT_SWIZZLE(w, y, z, y)
-IMPLEMENT_SWIZZLE(w, y, z, z)
-IMPLEMENT_SWIZZLE(w, y, z, w)
-IMPLEMENT_SWIZZLE(w, y, w, x)
-IMPLEMENT_SWIZZLE(w, y, w, y)
-IMPLEMENT_SWIZZLE(w, y, w, z)
-IMPLEMENT_SWIZZLE(w, y, w, w)
-IMPLEMENT_SWIZZLE(w, z, x, x)
-IMPLEMENT_SWIZZLE(w, z, x, y)
-IMPLEMENT_SWIZZLE(w, z, x, z)
-IMPLEMENT_SWIZZLE(w, z, x, w)
-IMPLEMENT_SWIZZLE(w, z, y, x)
-IMPLEMENT_SWIZZLE(w, z, y, y)
-IMPLEMENT_SWIZZLE(w, z, y, z)
-IMPLEMENT_SWIZZLE(w, z, y, w)
-IMPLEMENT_SWIZZLE(w, z, z, x)
-IMPLEMENT_SWIZZLE(w, z, z, y)
-IMPLEMENT_SWIZZLE(w, z, z, z)
-IMPLEMENT_SWIZZLE(w, z, z, w)
-IMPLEMENT_SWIZZLE(w, z, w, x)
-IMPLEMENT_SWIZZLE(w, z, w, y)
-IMPLEMENT_SWIZZLE(w, z, w, z)
-IMPLEMENT_SWIZZLE(w, z, w, w)
-IMPLEMENT_SWIZZLE(w, w, x, x)
-IMPLEMENT_SWIZZLE(w, w, x, y)
-IMPLEMENT_SWIZZLE(w, w, x, z)
-IMPLEMENT_SWIZZLE(w, w, x, w)
-IMPLEMENT_SWIZZLE(w, w, y, x)
-IMPLEMENT_SWIZZLE(w, w, y, y)
-IMPLEMENT_SWIZZLE(w, w, y, z)
-IMPLEMENT_SWIZZLE(w, w, y, w)
-IMPLEMENT_SWIZZLE(w, w, z, x)
-IMPLEMENT_SWIZZLE(w, w, z, y)
-IMPLEMENT_SWIZZLE(w, w, z, z)
-IMPLEMENT_SWIZZLE(w, w, z, w)
-IMPLEMENT_SWIZZLE(w, w, w, x)
-IMPLEMENT_SWIZZLE(w, w, w, y)
-IMPLEMENT_SWIZZLE(w, w, w, z)
-IMPLEMENT_SWIZZLE(w, w, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, x, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, z, z)
+// BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, y, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, z, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(x, w, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, x, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, y, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, z, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(y, w, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, x, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, y, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, z, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(z, w, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, x, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, y, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, z, w, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, x, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, x, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, x, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, x, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, y, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, y, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, y, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, y, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, z, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, z, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, z, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, z, w)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, w, x)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, w, y)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, w, z)
+BX_SIMD128_IMPLEMENT_SWIZZLE(w, w, w, w)

include/bx/simd_t.h

@@ -24,24 +24,10 @@
 #	include <xmmintrin.h> // __m128
 #	undef  BX_SIMD_SSE
 #	define BX_SIMD_SSE 1
-
-namespace bx
-{
-	typedef __m128 simd128_sse_t;
-
-} // namespace bx
-
 #elif defined(__ARM_NEON__) && !BX_COMPILER_CLANG
 #	include <arm_neon.h>
 #	undef  BX_SIMD_NEON
 #	define BX_SIMD_NEON 1
-
-namespace bx
-{
-	typedef float32x4_t simd128_neon_t;
-
-} // namespace bx
-
 #elif   BX_COMPILER_CLANG \
 	&& !BX_PLATFORM_EMSCRIPTEN \
 	&& !BX_PLATFORM_IOS \
@@ -49,73 +35,48 @@ namespace bx
 #	include <math.h>
 #	undef  BX_SIMD_LANGEXT
 #	define BX_SIMD_LANGEXT 1
-
-namespace bx
-{
-	union simd128_langext_t
-	{
-		float    __attribute__((vector_size(16))) vf;
-		int32_t  __attribute__((vector_size(16))) vi;
-		uint32_t __attribute__((vector_size(16))) vu;
-		float    fxyzw[4];
-		int32_t  ixyzw[4];
-		uint32_t uxyzw[4];
-
-	};
-} // namespace bx
 #endif //
 
-namespace bx
-{
-	union simd128_ref_t
-	{
-		float    fxyzw[4];
-		int32_t  ixyzw[4];
-		uint32_t uxyzw[4];
-
-	};
-} // namespace bx
-
 namespace bx
 {
 #define ELEMx 0
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			template<typename Ty> \
 			BX_SIMD_FORCE_INLINE Ty simd_swiz_##_x##_y##_z##_w(Ty _a);
 #include "simd_swizzle.inl"
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy
 #undef ELEMx
 
-#define IMPLEMENT_TEST(_xyzw) \
+#define BX_SIMD128_IMPLEMENT_TEST(_xyzw) \
 			template<typename Ty> \
 			BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(Ty _test); \
 			\
 			template<typename Ty> \
 			BX_SIMD_FORCE_INLINE bool simd_test_all_##_xyzw(Ty _test)
 
-IMPLEMENT_TEST(x   );
-IMPLEMENT_TEST(y   );
-IMPLEMENT_TEST(xy  );
-IMPLEMENT_TEST(z   );
-IMPLEMENT_TEST(xz  );
-IMPLEMENT_TEST(yz  );
-IMPLEMENT_TEST(xyz );
-IMPLEMENT_TEST(w   );
-IMPLEMENT_TEST(xw  );
-IMPLEMENT_TEST(yw  );
-IMPLEMENT_TEST(xyw );
-IMPLEMENT_TEST(zw  );
-IMPLEMENT_TEST(xzw );
-IMPLEMENT_TEST(yzw );
-IMPLEMENT_TEST(xyzw);
-#undef IMPLEMENT_TEST
+BX_SIMD128_IMPLEMENT_TEST(x   );
+BX_SIMD128_IMPLEMENT_TEST(y   );
+BX_SIMD128_IMPLEMENT_TEST(xy  );
+BX_SIMD128_IMPLEMENT_TEST(z   );
+BX_SIMD128_IMPLEMENT_TEST(xz  );
+BX_SIMD128_IMPLEMENT_TEST(yz  );
+BX_SIMD128_IMPLEMENT_TEST(xyz );
+BX_SIMD128_IMPLEMENT_TEST(w   );
+BX_SIMD128_IMPLEMENT_TEST(xw  );
+BX_SIMD128_IMPLEMENT_TEST(yw  );
+BX_SIMD128_IMPLEMENT_TEST(xyw );
+BX_SIMD128_IMPLEMENT_TEST(zw  );
+BX_SIMD128_IMPLEMENT_TEST(xzw );
+BX_SIMD128_IMPLEMENT_TEST(yzw );
+BX_SIMD128_IMPLEMENT_TEST(xyzw);
+#undef BX_SIMD128_IMPLEMENT_TEST
 
 	template<typename Ty>
 	BX_SIMD_FORCE_INLINE Ty simd_shuf_xyAB(Ty _a, Ty _b);
@@ -360,6 +321,35 @@ IMPLEMENT_TEST(xyzw);
 	template<typename Ty>
 	BX_SIMD_INLINE Ty simd_floor(Ty _a);
 
+#if BX_SIMD_SSE
+	typedef __m128 simd128_sse_t;
+#endif // BX_SIMD_SSE
+
+#if BX_SIMD_NEON
+	typedef float32x4_t simd128_neon_t;
+#endif // BX_SIMD_NEON
+
+#if BX_SIMD_LANGEXT
+	union simd128_langext_t
+	{
+		float    __attribute__((vector_size(16))) vf;
+		int32_t  __attribute__((vector_size(16))) vi;
+		uint32_t __attribute__((vector_size(16))) vu;
+		float    fxyzw[4];
+		int32_t  ixyzw[4];
+		uint32_t uxyzw[4];
+
+	};
+#endif // BX_SIMD_LANGEXT
+
+	union simd128_ref_t
+	{
+		float    fxyzw[4];
+		int32_t  ixyzw[4];
+		uint32_t uxyzw[4];
+
+	};
+
 } // namespace bx
 
 #if BX_SIMD_SSE
@@ -374,6 +364,10 @@ IMPLEMENT_TEST(xyzw);
 #	include "simd128_langext.inl"
 #endif // BX_SIMD_LANGEXT
 
+#include "simd128_ref.inl"
+
+namespace bx
+{
 #if !( BX_SIMD_SSE \
 	|| BX_SIMD_AVX \
 	|| BX_SIMD_NEON \
@@ -387,16 +381,9 @@ IMPLEMENT_TEST(xyzw);
 #		pragma message("************************************\nUsing SIMD reference implementation!\n************************************")
 #	endif // BX_SIMD_WARN_REFERENCE_IMPL
 
-namespace bx
-{
 	typedef simd128_ref_t simd128_t;
-}
 #endif //
 
-#include "simd128_ref.inl"
-
-namespace bx
-{
 	BX_SIMD_FORCE_INLINE simd128_t simd_zero()
 	{
 		return simd_zero<simd128_t>();

scripts/bx.lua

@@ -21,4 +21,5 @@ project "bx"
 
 	files {
 		"../include/**.h",
+		"../include/**.inl",
 	}

tests/simd_t.cpp

@@ -95,12 +95,12 @@ TEST(simd_swizzle)
 #define ELEMy 1
 #define ELEMz 2
 #define ELEMw 3
-#define IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
+#define BX_SIMD128_IMPLEMENT_SWIZZLE(_x, _y, _z, _w) \
 			simd_check_string("" #_x #_y #_z #_w "", simd_swiz_##_x##_y##_z##_w(xyzw) ); \
 
 #include <bx/simd_swizzle.inl>
 
-#undef IMPLEMENT_SWIZZLE
+#undef BX_SIMD128_IMPLEMENT_SWIZZLE
 #undef ELEMw
 #undef ELEMz
 #undef ELEMy

tests/vector_nodefault.cpp

@@ -33,10 +33,14 @@
 #include <string.h>
 #include <stdlib.h>
 
+#if !BX_CRT_MSVC
+#	define _strdup strdup
+#endif // !BX_CRT_MSVC
+
 struct nodefault {
-	nodefault(const char* s) { data = strdup(s); }
+	nodefault(const char* s) { data = _strdup(s); }
 	~nodefault() { free(data); }
-	nodefault(const nodefault& other) { data = 0; if (other.data) data = strdup(other.data); }
+	nodefault(const nodefault& other) { data = 0; if (other.data) data = _strdup(other.data); }
 	nodefault& operator=(const nodefault& other) { nodefault(other).swap(*this); return *this; }
 	void swap(nodefault& other) { std::swap(data, other.data); }
 
@@ -148,7 +152,7 @@ TEST(vector_nodefault_popback) {
 	v.push_back("24");
 
 	CHECK(v.back() == "24");
-	
+
 	v.pop_back();
 
 	CHECK(v.back() == "12");