Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-17 20:52:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup.

Browse Source
This commit is contained in:
Branimir Karadžić
2016-07-18 22:42:26 -07:00
parent 224e990ee4
commit e4cba5577a
9 changed files with 393 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
include/bx/simd128_langext.inl
View File

@@ -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)

36
include/bx/simd128_neon.inl
View File

@@ -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)

38
include/bx/simd128_ref.inl
View File

@@ -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)

38
include/bx/simd128_sse.inl
View File

@@ -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)

512
include/bx/simd_swizzle.inl
View File

@@ -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)

117
include/bx/simd_t.h
View File

@@ -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>();

1
scripts/bx.lua
View File

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

4
tests/simd_t.cpp
View File

@@ -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

10
tests/vector_nodefault.cpp
View File

@@ -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");