From e4cba5577a5fa61a44ba80778d2303bd4e1e7d95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Mon, 18 Jul 2016 22:42:26 -0700 Subject: [PATCH] Cleanup. --- include/bx/simd128_langext.inl | 38 +-- include/bx/simd128_neon.inl | 36 +-- include/bx/simd128_ref.inl | 38 +-- include/bx/simd128_sse.inl | 38 +-- include/bx/simd_swizzle.inl | 512 ++++++++++++++++----------------- include/bx/simd_t.h | 117 ++++---- scripts/bx.lua | 1 + tests/simd_t.cpp | 4 +- tests/vector_nodefault.cpp | 10 +- 9 files changed, 393 insertions(+), 401 deletions(-) diff --git a/include/bx/simd128_langext.inl b/include/bx/simd128_langext.inl index 4557a56..2008e76 100644 --- a/include/bx/simd128_langext.inl +++ b/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); +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 IMPLEMENT_TEST +#undef BX_SIMD128_IMPLEMENT_TEST template<> BX_SIMD_FORCE_INLINE simd_langext_t float4_shuf_xyAB(simd_langext_t _a, simd_langext_t _b) diff --git a/include/bx/simd128_neon.inl b/include/bx/simd128_neon.inl index 4f29bc3..42316a2 100644 --- a/include/bx/simd128_neon.inl +++ 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) diff --git a/include/bx/simd128_ref.inl b/include/bx/simd128_ref.inl index 85f54e8..938326a 100644 --- a/include/bx/simd128_ref.inl +++ b/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); +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 IMPLEMENT_TEST +#undef BX_SIMD128_IMPLEMENT_TEST template<> BX_SIMD_FORCE_INLINE simd128_ref_t simd_shuf_xyAB(simd128_ref_t _a, simd128_ref_t _b) diff --git a/include/bx/simd128_sse.inl b/include/bx/simd128_sse.inl index f68ea26..2a00c75 100644 --- a/include/bx/simd128_sse.inl +++ 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); +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 IMPLEMENT_TEST +#undef BX_SIMD128_IMPLEMENT_TEST template<> BX_SIMD_FORCE_INLINE simd128_sse_t simd_shuf_xyAB(simd128_sse_t _a, simd128_sse_t _b) diff --git a/include/bx/simd_swizzle.inl b/include/bx/simd_swizzle.inl index d0c750c..4185be8 100644 --- a/include/bx/simd_swizzle.inl +++ 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) diff --git a/include/bx/simd_t.h b/include/bx/simd_t.h index e9fa95d..a2a31d1 100644 --- a/include/bx/simd_t.h +++ b/include/bx/simd_t.h @@ -24,24 +24,10 @@ # include // __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 # 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 # 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 \ 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 \ BX_SIMD_FORCE_INLINE bool simd_test_any_##_xyzw(Ty _test); \ \ template \ 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 BX_SIMD_FORCE_INLINE Ty simd_shuf_xyAB(Ty _a, Ty _b); @@ -360,6 +321,35 @@ IMPLEMENT_TEST(xyzw); template 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(); diff --git a/scripts/bx.lua b/scripts/bx.lua index aa09b05..8cae8b4 100644 --- a/scripts/bx.lua +++ b/scripts/bx.lua @@ -21,4 +21,5 @@ project "bx" files { "../include/**.h", + "../include/**.inl", } diff --git a/tests/simd_t.cpp b/tests/simd_t.cpp index e8f2ef0..713de11 100644 --- a/tests/simd_t.cpp +++ b/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 -#undef IMPLEMENT_SWIZZLE +#undef BX_SIMD128_IMPLEMENT_SWIZZLE #undef ELEMw #undef ELEMz #undef ELEMy diff --git a/tests/vector_nodefault.cpp b/tests/vector_nodefault.cpp index 4a8bc8c..1340b0c 100644 --- a/tests/vector_nodefault.cpp +++ b/tests/vector_nodefault.cpp @@ -33,10 +33,14 @@ #include #include +#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");