Reactor: Switch swizzles over to 16-bit hex codes
This migrates from 2-bit swizzle codes per lane to 4-bit, which reads more fluently in hex.
The order has been reversed so that the most significant nibble (leftmost on little-endian CPUs) represents the first output lane.
Fixed up Swizzle, Mask, and ShuffleLowHigh
Bug: b/145746360
Change-Id: I132bd757801a5ca543ef2b9b0ed34d0527db5bfa
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/39049
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
Reviewed-by: David Turner <digit@google.com>
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
Tested-by: Ben Clayton <bclayton@google.com>
diff --git a/src/Device/QuadRasterizer.cpp b/src/Device/QuadRasterizer.cpp
index a3494d8..0f23599 100644
--- a/src/Device/QuadRasterizer.cpp
+++ b/src/Device/QuadRasterizer.cpp
@@ -179,8 +179,8 @@
xLeft[q] = *Pointer<Short4>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline) + y * sizeof(Primitive::Span));
xRight[q] = xLeft[q];
- xLeft[q] = Swizzle(xLeft[q], 0xA0) - Short4(1, 2, 1, 2);
- xRight[q] = Swizzle(xRight[q], 0xF5) - Short4(0, 1, 0, 1);
+ xLeft[q] = Swizzle(xLeft[q], 0x0022) - Short4(1, 2, 1, 2);
+ xRight[q] = Swizzle(xRight[q], 0x1133) - Short4(0, 1, 0, 1);
}
For(Int x = x0, x < x1, x += 2)
diff --git a/src/Main/FrameBuffer.cpp b/src/Main/FrameBuffer.cpp
index 5e4f6c3..2dc5cd6 100644
--- a/src/Main/FrameBuffer.cpp
+++ b/src/Main/FrameBuffer.cpp
@@ -217,8 +217,8 @@
case FORMAT_A16B16G16R16:
For(, x < width - 1, x += 2)
{
- Short4 c0 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 0), 0xC6)) >> 8;
- Short4 c1 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 8), 0xC6)) >> 8;
+ Short4 c0 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 0), 0x2103)) >> 8;
+ Short4 c1 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 8), 0x2103)) >> 8;
*Pointer<Int2>(d) = As<Int2>(PackUnsigned(c0, c1));
@@ -264,7 +264,7 @@
break;
case FORMAT_A16B16G16R16:
{
- Short4 c = As<UShort4>(Swizzle(*Pointer<Short4>(s), 0xC6)) >> 8;
+ Short4 c = As<UShort4>(Swizzle(*Pointer<Short4>(s), 0x2103)) >> 8;
*Pointer<Int>(d) = Int(As<Int2>(PackUnsigned(c, c)));
}
@@ -545,10 +545,10 @@
break;
case FORMAT_X8B8G8R8:
case FORMAT_A8B8G8R8:
- c2 = Swizzle(Unpack(*Pointer<Byte4>(s)), 0xC6);
+ c2 = Swizzle(Unpack(*Pointer<Byte4>(s)), 0x2103);
break;
case FORMAT_A16B16G16R16:
- c2 = Swizzle(*Pointer<Short4>(s), 0xC6);
+ c2 = Swizzle(*Pointer<Short4>(s), 0x2103);
break;
case FORMAT_R5G6B5:
{
@@ -568,7 +568,7 @@
c1 = As<Short4>(As<UShort4>(c1) >> 9);
c2 = As<Short4>(As<UShort4>(c2) >> 9);
- Short4 alpha = Swizzle(c1, 0xFF) & Short4(0xFFFFu, 0xFFFFu, 0xFFFFu, 0x0000);
+ Short4 alpha = Swizzle(c1, 0x3333) & Short4(0xFFFFu, 0xFFFFu, 0xFFFFu, 0x0000);
c1 = (c1 - c2) * alpha;
c1 = c1 >> 7;
@@ -586,7 +586,7 @@
case FORMAT_SRGB8_X8:
case FORMAT_SRGB8_A8:
{
- c1 = Swizzle(c1, 0xC6);
+ c1 = Swizzle(c1, 0x2103);
*Pointer<Byte4>(d) = Byte4(PackUnsigned(c1, c1));
}
diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
index 999afe8..6fe6e74 100644
--- a/src/Pipeline/PixelRoutine.cpp
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -1852,8 +1852,8 @@
buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
pixel.y = *Pointer<Float4>(buffer + 8 * x, 16);
pixel.z = pixel.x;
- pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x88);
- pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0xDD);
+ pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x0202);
+ pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0x1313);
pixel.y = pixel.z;
pixel.z = pixel.w = one;
break;
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 0360138..05d4b42 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -2604,7 +2604,7 @@
#else
auto result = V(lowerPack(V(x.value), V(y.value), true));
#endif
- return As<SByte8>(Swizzle(As<Int4>(result), 0x88));
+ return As<SByte8>(Swizzle(As<Int4>(result), 0x0202));
}
RValue<Byte8> PackUnsigned(RValue<Short4> x, RValue<Short4> y)
@@ -2615,7 +2615,7 @@
#else
auto result = V(lowerPack(V(x.value), V(y.value), false));
#endif
- return As<Byte8>(Swizzle(As<Int4>(result), 0x88));
+ return As<Byte8>(Swizzle(As<Int4>(result), 0x0202));
}
RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y)
diff --git a/src/Reactor/Reactor.cpp b/src/Reactor/Reactor.cpp
index 6f6a8de..a90f967 100644
--- a/src/Reactor/Reactor.cpp
+++ b/src/Reactor/Reactor.cpp
@@ -113,18 +113,17 @@
//
// msb lsb
// v v
- // [.aaa|.bbb|.ccc|.ddd] where '.' means an ignored bit
+ // [.xxx|.yyy|.zzz|.www] where '.' means an ignored bit
//
// This format makes it easy to write calls with hexadecimal select values,
- // since each hex digit is a separate swizzle index. Note that the order
- // of indices is reversed compared to createSwizzle4() below!
+ // since each hex digit is a separate swizzle index.
//
// For example:
// createBlend4( [a,b,c,d], [e,f,g,h], 0x0123 ) -> [a,b,c,d]
// createBlend4( [a,b,c,d], [e,f,g,h], 0x4567 ) -> [e,f,g,h]
// createBlend4( [a,b,c,d], [e,f,g,h], 0x4012 ) -> [e,a,b,c]
//
- static Value *createBlend4(Value *lhs, Value *rhs, unsigned short select)
+ static Value *createBlend4(Value *lhs, Value *rhs, uint16_t select)
{
int swizzle[4] =
{
@@ -137,27 +136,41 @@
return Nucleus::createShuffleVector(lhs, rhs, swizzle);
}
- static Value *createSwizzle4(Value *val, unsigned char select)
+ // NOTE: Only 8 bits out of 16 of the |select| value are used.
+ // More specifically, the value should look like:
+ //
+ // msb lsb
+ // v v
+ // [..xx|..yy|..zz|..ww] where '.' means an ignored bit
+ //
+ // This format makes it easy to write calls with hexadecimal select values,
+ // since each hex digit is a separate swizzle index.
+ //
+ // For example:
+ // createSwizzle4( [a,b,c,d], 0x0123 ) -> [a,b,c,d]
+ // createSwizzle4( [a,b,c,d], 0x0033 ) -> [a,a,d,d]
+ //
+ static Value *createSwizzle4(Value *val, uint16_t select)
{
int swizzle[4] =
{
- (select >> 0) & 0x03,
- (select >> 2) & 0x03,
- (select >> 4) & 0x03,
- (select >> 6) & 0x03,
+ (select >> 12) & 0x03,
+ (select >> 8) & 0x03,
+ (select >> 4) & 0x03,
+ (select >> 0) & 0x03,
};
return Nucleus::createShuffleVector(val, val, swizzle);
}
- static Value *createMask4(Value *lhs, Value *rhs, unsigned char select)
+ static Value *createMask4(Value *lhs, Value *rhs, uint16_t select)
{
bool mask[4] = {false, false, false, false};
- mask[(select >> 0) & 0x03] = true;
- mask[(select >> 2) & 0x03] = true;
- mask[(select >> 4) & 0x03] = true;
- mask[(select >> 6) & 0x03] = true;
+ mask[(select >> 12) & 0x03] = true;
+ mask[(select >> 8) & 0x03] = true;
+ mask[(select >> 4) & 0x03] = true;
+ mask[(select >> 0) & 0x03] = true;
int swizzle[4] =
{
@@ -1428,7 +1441,7 @@
{
int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23}; // Real type is v16i8
auto lowHigh = RValue<Byte16>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
- return As<Short4>(Swizzle(As<Int4>(lowHigh), 0xEE));
+ return As<Short4>(Swizzle(As<Int4>(lowHigh), 0x2323));
}
SByte8::SByte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7)
@@ -1604,7 +1617,7 @@
{
int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23}; // Real type is v16i8
auto lowHigh = RValue<Byte16>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
- return As<Short4>(Swizzle(As<Int4>(lowHigh), 0xEE));
+ return As<Short4>(Swizzle(As<Int4>(lowHigh), 0x2323));
}
Byte16::Byte16(RValue<Byte16> rhs)
@@ -1662,7 +1675,7 @@
Value *vector = loadValue();
Value *element = Nucleus::createTrunc(cast.value, Short::getType());
Value *insert = Nucleus::createInsertElement(vector, element, 0);
- Value *swizzle = Swizzle(RValue<Short4>(insert), 0x00).value;
+ Value *swizzle = Swizzle(RValue<Short4>(insert), 0x0000).value;
storeValue(swizzle);
}
@@ -1882,22 +1895,22 @@
{
int shuffle[8] = {0, 8, 1, 9, 2, 10, 3, 11}; // Real type is v8i16
auto lowHigh = RValue<Short8>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
- return As<Int2>(Swizzle(As<Int4>(lowHigh), 0xEE));
+ return As<Int2>(Swizzle(As<Int4>(lowHigh), 0x2323));
}
- RValue<Short4> Swizzle(RValue<Short4> x, unsigned char select)
+ RValue<Short4> Swizzle(RValue<Short4> x, uint16_t select)
{
// Real type is v8i16
int shuffle[8] =
{
- (select >> 0) & 0x03,
- (select >> 2) & 0x03,
- (select >> 4) & 0x03,
- (select >> 6) & 0x03,
- (select >> 0) & 0x03,
- (select >> 2) & 0x03,
- (select >> 4) & 0x03,
- (select >> 6) & 0x03,
+ (select >> 12) & 0x03,
+ (select >> 8) & 0x03,
+ (select >> 4) & 0x03,
+ (select >> 0) & 0x03,
+ (select >> 12) & 0x03,
+ (select >> 8) & 0x03,
+ (select >> 4) & 0x03,
+ (select >> 0) & 0x03,
};
return As<Short4>(Nucleus::createShuffleVector(x.value, x.value, shuffle));
@@ -3094,7 +3107,7 @@
{
int shuffle[4] = {0, 4, 1, 5}; // Real type is v4i32
auto lowHigh = RValue<Int4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
- return As<Short4>(Swizzle(lowHigh, 0xEE));
+ return As<Short4>(Swizzle(lowHigh, 0x2323));
}
RValue<Int> Extract(RValue<Int2> val, int i)
@@ -3505,7 +3518,7 @@
return RValue<Int4>(Nucleus::createInsertElement(x.value, element.value, i));
}
- RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select)
+ RValue<Int4> Swizzle(RValue<Int4> x, uint16_t select)
{
return RValue<Int4>(createSwizzle4(x.value, select));
}
@@ -3745,7 +3758,7 @@
return RValue<UInt4>(Nucleus::createInsertElement(x.value, element.value, i));
}
- RValue<UInt4> Swizzle(RValue<UInt4> x, unsigned char select)
+ RValue<UInt4> Swizzle(RValue<UInt4> x, uint16_t select)
{
return RValue<UInt4>(createSwizzle4(x.value, select));
}
@@ -4245,24 +4258,24 @@
return RValue<Float>(Nucleus::createExtractElement(x.value, Float::getType(), i));
}
- RValue<Float4> Swizzle(RValue<Float4> x, unsigned char select)
+ RValue<Float4> Swizzle(RValue<Float4> x, uint16_t select)
{
return RValue<Float4>(createSwizzle4(x.value, select));
}
- RValue<Float4> Blend(RValue<Float4> x, RValue<Float4> y, unsigned short select)
+ RValue<Float4> Blend(RValue<Float4> x, RValue<Float4> y, uint16_t select)
{
return RValue<Float4>(createBlend4(x.value, y.value, select));
}
- RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm)
+ RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, uint16_t imm)
{
int shuffle[4] =
{
- ((imm >> 0) & 0x03) + 0,
- ((imm >> 2) & 0x03) + 0,
- ((imm >> 4) & 0x03) + 4,
- ((imm >> 6) & 0x03) + 4,
+ ((imm >> 12) & 0x03) + 0,
+ ((imm >> 8) & 0x03) + 0,
+ ((imm >> 4) & 0x03) + 4,
+ ((imm >> 0) & 0x03) + 4,
};
return RValue<Float4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
@@ -4280,7 +4293,7 @@
return RValue<Float4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
}
- RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select)
+ RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, uint16_t select)
{
Value *vector = lhs.loadValue();
Value *result = createMask4(vector, rhs.value, select);
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index 5fdc73a..8dc3a2f 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -883,7 +883,7 @@
RValue<Byte8> PackUnsigned(RValue<Short4> x, RValue<Short4> y);
RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y);
RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y);
- RValue<Short4> Swizzle(RValue<Short4> x, unsigned char select);
+ RValue<Short4> Swizzle(RValue<Short4> x, uint16_t select);
RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i);
RValue<Short> Extract(RValue<Short4> val, int i);
RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y);
@@ -1505,346 +1505,346 @@
public:
union
{
- SwizzleMask1<Vector4, 0x00> x;
- SwizzleMask1<Vector4, 0x55> y;
- SwizzleMask1<Vector4, 0xAA> z;
- SwizzleMask1<Vector4, 0xFF> w;
- Swizzle2<Vector4, 0x00> xx;
- Swizzle2<Vector4, 0x01> yx;
- Swizzle2<Vector4, 0x02> zx;
- Swizzle2<Vector4, 0x03> wx;
- SwizzleMask2<Vector4, 0x54> xy;
- Swizzle2<Vector4, 0x55> yy;
- Swizzle2<Vector4, 0x56> zy;
- Swizzle2<Vector4, 0x57> wy;
- SwizzleMask2<Vector4, 0xA8> xz;
- SwizzleMask2<Vector4, 0xA9> yz;
- Swizzle2<Vector4, 0xAA> zz;
- Swizzle2<Vector4, 0xAB> wz;
- SwizzleMask2<Vector4, 0xFC> xw;
- SwizzleMask2<Vector4, 0xFD> yw;
- SwizzleMask2<Vector4, 0xFE> zw;
- Swizzle2<Vector4, 0xFF> ww;
- Swizzle4<Vector4, 0x00> xxx;
- Swizzle4<Vector4, 0x01> yxx;
- Swizzle4<Vector4, 0x02> zxx;
- Swizzle4<Vector4, 0x03> wxx;
- Swizzle4<Vector4, 0x04> xyx;
- Swizzle4<Vector4, 0x05> yyx;
- Swizzle4<Vector4, 0x06> zyx;
- Swizzle4<Vector4, 0x07> wyx;
- Swizzle4<Vector4, 0x08> xzx;
- Swizzle4<Vector4, 0x09> yzx;
- Swizzle4<Vector4, 0x0A> zzx;
- Swizzle4<Vector4, 0x0B> wzx;
- Swizzle4<Vector4, 0x0C> xwx;
- Swizzle4<Vector4, 0x0D> ywx;
- Swizzle4<Vector4, 0x0E> zwx;
- Swizzle4<Vector4, 0x0F> wwx;
- Swizzle4<Vector4, 0x50> xxy;
- Swizzle4<Vector4, 0x51> yxy;
- Swizzle4<Vector4, 0x52> zxy;
- Swizzle4<Vector4, 0x53> wxy;
- Swizzle4<Vector4, 0x54> xyy;
- Swizzle4<Vector4, 0x55> yyy;
- Swizzle4<Vector4, 0x56> zyy;
- Swizzle4<Vector4, 0x57> wyy;
- Swizzle4<Vector4, 0x58> xzy;
- Swizzle4<Vector4, 0x59> yzy;
- Swizzle4<Vector4, 0x5A> zzy;
- Swizzle4<Vector4, 0x5B> wzy;
- Swizzle4<Vector4, 0x5C> xwy;
- Swizzle4<Vector4, 0x5D> ywy;
- Swizzle4<Vector4, 0x5E> zwy;
- Swizzle4<Vector4, 0x5F> wwy;
- Swizzle4<Vector4, 0xA0> xxz;
- Swizzle4<Vector4, 0xA1> yxz;
- Swizzle4<Vector4, 0xA2> zxz;
- Swizzle4<Vector4, 0xA3> wxz;
- SwizzleMask4<Vector4, 0xA4> xyz;
- Swizzle4<Vector4, 0xA5> yyz;
- Swizzle4<Vector4, 0xA6> zyz;
- Swizzle4<Vector4, 0xA7> wyz;
- Swizzle4<Vector4, 0xA8> xzz;
- Swizzle4<Vector4, 0xA9> yzz;
- Swizzle4<Vector4, 0xAA> zzz;
- Swizzle4<Vector4, 0xAB> wzz;
- Swizzle4<Vector4, 0xAC> xwz;
- Swizzle4<Vector4, 0xAD> ywz;
- Swizzle4<Vector4, 0xAE> zwz;
- Swizzle4<Vector4, 0xAF> wwz;
- Swizzle4<Vector4, 0xF0> xxw;
- Swizzle4<Vector4, 0xF1> yxw;
- Swizzle4<Vector4, 0xF2> zxw;
- Swizzle4<Vector4, 0xF3> wxw;
- SwizzleMask4<Vector4, 0xF4> xyw;
- Swizzle4<Vector4, 0xF5> yyw;
- Swizzle4<Vector4, 0xF6> zyw;
- Swizzle4<Vector4, 0xF7> wyw;
- SwizzleMask4<Vector4, 0xF8> xzw;
- SwizzleMask4<Vector4, 0xF9> yzw;
- Swizzle4<Vector4, 0xFA> zzw;
- Swizzle4<Vector4, 0xFB> wzw;
- Swizzle4<Vector4, 0xFC> xww;
- Swizzle4<Vector4, 0xFD> yww;
- Swizzle4<Vector4, 0xFE> zww;
- Swizzle4<Vector4, 0xFF> www;
- Swizzle4<Vector4, 0x00> xxxx;
- Swizzle4<Vector4, 0x01> yxxx;
- Swizzle4<Vector4, 0x02> zxxx;
- Swizzle4<Vector4, 0x03> wxxx;
- Swizzle4<Vector4, 0x04> xyxx;
- Swizzle4<Vector4, 0x05> yyxx;
- Swizzle4<Vector4, 0x06> zyxx;
- Swizzle4<Vector4, 0x07> wyxx;
- Swizzle4<Vector4, 0x08> xzxx;
- Swizzle4<Vector4, 0x09> yzxx;
- Swizzle4<Vector4, 0x0A> zzxx;
- Swizzle4<Vector4, 0x0B> wzxx;
- Swizzle4<Vector4, 0x0C> xwxx;
- Swizzle4<Vector4, 0x0D> ywxx;
- Swizzle4<Vector4, 0x0E> zwxx;
- Swizzle4<Vector4, 0x0F> wwxx;
- Swizzle4<Vector4, 0x10> xxyx;
- Swizzle4<Vector4, 0x11> yxyx;
- Swizzle4<Vector4, 0x12> zxyx;
- Swizzle4<Vector4, 0x13> wxyx;
- Swizzle4<Vector4, 0x14> xyyx;
- Swizzle4<Vector4, 0x15> yyyx;
- Swizzle4<Vector4, 0x16> zyyx;
- Swizzle4<Vector4, 0x17> wyyx;
- Swizzle4<Vector4, 0x18> xzyx;
- Swizzle4<Vector4, 0x19> yzyx;
- Swizzle4<Vector4, 0x1A> zzyx;
- Swizzle4<Vector4, 0x1B> wzyx;
- Swizzle4<Vector4, 0x1C> xwyx;
- Swizzle4<Vector4, 0x1D> ywyx;
- Swizzle4<Vector4, 0x1E> zwyx;
- Swizzle4<Vector4, 0x1F> wwyx;
- Swizzle4<Vector4, 0x20> xxzx;
- Swizzle4<Vector4, 0x21> yxzx;
- Swizzle4<Vector4, 0x22> zxzx;
- Swizzle4<Vector4, 0x23> wxzx;
- Swizzle4<Vector4, 0x24> xyzx;
- Swizzle4<Vector4, 0x25> yyzx;
- Swizzle4<Vector4, 0x26> zyzx;
- Swizzle4<Vector4, 0x27> wyzx;
- Swizzle4<Vector4, 0x28> xzzx;
- Swizzle4<Vector4, 0x29> yzzx;
- Swizzle4<Vector4, 0x2A> zzzx;
- Swizzle4<Vector4, 0x2B> wzzx;
- Swizzle4<Vector4, 0x2C> xwzx;
- Swizzle4<Vector4, 0x2D> ywzx;
- Swizzle4<Vector4, 0x2E> zwzx;
- Swizzle4<Vector4, 0x2F> wwzx;
- Swizzle4<Vector4, 0x30> xxwx;
- Swizzle4<Vector4, 0x31> yxwx;
- Swizzle4<Vector4, 0x32> zxwx;
- Swizzle4<Vector4, 0x33> wxwx;
- Swizzle4<Vector4, 0x34> xywx;
- Swizzle4<Vector4, 0x35> yywx;
- Swizzle4<Vector4, 0x36> zywx;
- Swizzle4<Vector4, 0x37> wywx;
- Swizzle4<Vector4, 0x38> xzwx;
- Swizzle4<Vector4, 0x39> yzwx;
- Swizzle4<Vector4, 0x3A> zzwx;
- Swizzle4<Vector4, 0x3B> wzwx;
- Swizzle4<Vector4, 0x3C> xwwx;
- Swizzle4<Vector4, 0x3D> ywwx;
- Swizzle4<Vector4, 0x3E> zwwx;
- Swizzle4<Vector4, 0x3F> wwwx;
- Swizzle4<Vector4, 0x40> xxxy;
- Swizzle4<Vector4, 0x41> yxxy;
- Swizzle4<Vector4, 0x42> zxxy;
- Swizzle4<Vector4, 0x43> wxxy;
- Swizzle4<Vector4, 0x44> xyxy;
- Swizzle4<Vector4, 0x45> yyxy;
- Swizzle4<Vector4, 0x46> zyxy;
- Swizzle4<Vector4, 0x47> wyxy;
- Swizzle4<Vector4, 0x48> xzxy;
- Swizzle4<Vector4, 0x49> yzxy;
- Swizzle4<Vector4, 0x4A> zzxy;
- Swizzle4<Vector4, 0x4B> wzxy;
- Swizzle4<Vector4, 0x4C> xwxy;
- Swizzle4<Vector4, 0x4D> ywxy;
- Swizzle4<Vector4, 0x4E> zwxy;
- Swizzle4<Vector4, 0x4F> wwxy;
- Swizzle4<Vector4, 0x50> xxyy;
- Swizzle4<Vector4, 0x51> yxyy;
- Swizzle4<Vector4, 0x52> zxyy;
- Swizzle4<Vector4, 0x53> wxyy;
- Swizzle4<Vector4, 0x54> xyyy;
- Swizzle4<Vector4, 0x55> yyyy;
- Swizzle4<Vector4, 0x56> zyyy;
- Swizzle4<Vector4, 0x57> wyyy;
- Swizzle4<Vector4, 0x58> xzyy;
- Swizzle4<Vector4, 0x59> yzyy;
- Swizzle4<Vector4, 0x5A> zzyy;
- Swizzle4<Vector4, 0x5B> wzyy;
- Swizzle4<Vector4, 0x5C> xwyy;
- Swizzle4<Vector4, 0x5D> ywyy;
- Swizzle4<Vector4, 0x5E> zwyy;
- Swizzle4<Vector4, 0x5F> wwyy;
- Swizzle4<Vector4, 0x60> xxzy;
- Swizzle4<Vector4, 0x61> yxzy;
- Swizzle4<Vector4, 0x62> zxzy;
- Swizzle4<Vector4, 0x63> wxzy;
- Swizzle4<Vector4, 0x64> xyzy;
- Swizzle4<Vector4, 0x65> yyzy;
- Swizzle4<Vector4, 0x66> zyzy;
- Swizzle4<Vector4, 0x67> wyzy;
- Swizzle4<Vector4, 0x68> xzzy;
- Swizzle4<Vector4, 0x69> yzzy;
- Swizzle4<Vector4, 0x6A> zzzy;
- Swizzle4<Vector4, 0x6B> wzzy;
- Swizzle4<Vector4, 0x6C> xwzy;
- Swizzle4<Vector4, 0x6D> ywzy;
- Swizzle4<Vector4, 0x6E> zwzy;
- Swizzle4<Vector4, 0x6F> wwzy;
- Swizzle4<Vector4, 0x70> xxwy;
- Swizzle4<Vector4, 0x71> yxwy;
- Swizzle4<Vector4, 0x72> zxwy;
- Swizzle4<Vector4, 0x73> wxwy;
- Swizzle4<Vector4, 0x74> xywy;
- Swizzle4<Vector4, 0x75> yywy;
- Swizzle4<Vector4, 0x76> zywy;
- Swizzle4<Vector4, 0x77> wywy;
- Swizzle4<Vector4, 0x78> xzwy;
- Swizzle4<Vector4, 0x79> yzwy;
- Swizzle4<Vector4, 0x7A> zzwy;
- Swizzle4<Vector4, 0x7B> wzwy;
- Swizzle4<Vector4, 0x7C> xwwy;
- Swizzle4<Vector4, 0x7D> ywwy;
- Swizzle4<Vector4, 0x7E> zwwy;
- Swizzle4<Vector4, 0x7F> wwwy;
- Swizzle4<Vector4, 0x80> xxxz;
- Swizzle4<Vector4, 0x81> yxxz;
- Swizzle4<Vector4, 0x82> zxxz;
- Swizzle4<Vector4, 0x83> wxxz;
- Swizzle4<Vector4, 0x84> xyxz;
- Swizzle4<Vector4, 0x85> yyxz;
- Swizzle4<Vector4, 0x86> zyxz;
- Swizzle4<Vector4, 0x87> wyxz;
- Swizzle4<Vector4, 0x88> xzxz;
- Swizzle4<Vector4, 0x89> yzxz;
- Swizzle4<Vector4, 0x8A> zzxz;
- Swizzle4<Vector4, 0x8B> wzxz;
- Swizzle4<Vector4, 0x8C> xwxz;
- Swizzle4<Vector4, 0x8D> ywxz;
- Swizzle4<Vector4, 0x8E> zwxz;
- Swizzle4<Vector4, 0x8F> wwxz;
- Swizzle4<Vector4, 0x90> xxyz;
- Swizzle4<Vector4, 0x91> yxyz;
- Swizzle4<Vector4, 0x92> zxyz;
- Swizzle4<Vector4, 0x93> wxyz;
- Swizzle4<Vector4, 0x94> xyyz;
- Swizzle4<Vector4, 0x95> yyyz;
- Swizzle4<Vector4, 0x96> zyyz;
- Swizzle4<Vector4, 0x97> wyyz;
- Swizzle4<Vector4, 0x98> xzyz;
- Swizzle4<Vector4, 0x99> yzyz;
- Swizzle4<Vector4, 0x9A> zzyz;
- Swizzle4<Vector4, 0x9B> wzyz;
- Swizzle4<Vector4, 0x9C> xwyz;
- Swizzle4<Vector4, 0x9D> ywyz;
- Swizzle4<Vector4, 0x9E> zwyz;
- Swizzle4<Vector4, 0x9F> wwyz;
- Swizzle4<Vector4, 0xA0> xxzz;
- Swizzle4<Vector4, 0xA1> yxzz;
- Swizzle4<Vector4, 0xA2> zxzz;
- Swizzle4<Vector4, 0xA3> wxzz;
- Swizzle4<Vector4, 0xA4> xyzz;
- Swizzle4<Vector4, 0xA5> yyzz;
- Swizzle4<Vector4, 0xA6> zyzz;
- Swizzle4<Vector4, 0xA7> wyzz;
- Swizzle4<Vector4, 0xA8> xzzz;
- Swizzle4<Vector4, 0xA9> yzzz;
- Swizzle4<Vector4, 0xAA> zzzz;
- Swizzle4<Vector4, 0xAB> wzzz;
- Swizzle4<Vector4, 0xAC> xwzz;
- Swizzle4<Vector4, 0xAD> ywzz;
- Swizzle4<Vector4, 0xAE> zwzz;
- Swizzle4<Vector4, 0xAF> wwzz;
- Swizzle4<Vector4, 0xB0> xxwz;
- Swizzle4<Vector4, 0xB1> yxwz;
- Swizzle4<Vector4, 0xB2> zxwz;
- Swizzle4<Vector4, 0xB3> wxwz;
- Swizzle4<Vector4, 0xB4> xywz;
- Swizzle4<Vector4, 0xB5> yywz;
- Swizzle4<Vector4, 0xB6> zywz;
- Swizzle4<Vector4, 0xB7> wywz;
- Swizzle4<Vector4, 0xB8> xzwz;
- Swizzle4<Vector4, 0xB9> yzwz;
- Swizzle4<Vector4, 0xBA> zzwz;
- Swizzle4<Vector4, 0xBB> wzwz;
- Swizzle4<Vector4, 0xBC> xwwz;
- Swizzle4<Vector4, 0xBD> ywwz;
- Swizzle4<Vector4, 0xBE> zwwz;
- Swizzle4<Vector4, 0xBF> wwwz;
- Swizzle4<Vector4, 0xC0> xxxw;
- Swizzle4<Vector4, 0xC1> yxxw;
- Swizzle4<Vector4, 0xC2> zxxw;
- Swizzle4<Vector4, 0xC3> wxxw;
- Swizzle4<Vector4, 0xC4> xyxw;
- Swizzle4<Vector4, 0xC5> yyxw;
- Swizzle4<Vector4, 0xC6> zyxw;
- Swizzle4<Vector4, 0xC7> wyxw;
- Swizzle4<Vector4, 0xC8> xzxw;
- Swizzle4<Vector4, 0xC9> yzxw;
- Swizzle4<Vector4, 0xCA> zzxw;
- Swizzle4<Vector4, 0xCB> wzxw;
- Swizzle4<Vector4, 0xCC> xwxw;
- Swizzle4<Vector4, 0xCD> ywxw;
- Swizzle4<Vector4, 0xCE> zwxw;
- Swizzle4<Vector4, 0xCF> wwxw;
- Swizzle4<Vector4, 0xD0> xxyw;
- Swizzle4<Vector4, 0xD1> yxyw;
- Swizzle4<Vector4, 0xD2> zxyw;
- Swizzle4<Vector4, 0xD3> wxyw;
- Swizzle4<Vector4, 0xD4> xyyw;
- Swizzle4<Vector4, 0xD5> yyyw;
- Swizzle4<Vector4, 0xD6> zyyw;
- Swizzle4<Vector4, 0xD7> wyyw;
- Swizzle4<Vector4, 0xD8> xzyw;
- Swizzle4<Vector4, 0xD9> yzyw;
- Swizzle4<Vector4, 0xDA> zzyw;
- Swizzle4<Vector4, 0xDB> wzyw;
- Swizzle4<Vector4, 0xDC> xwyw;
- Swizzle4<Vector4, 0xDD> ywyw;
- Swizzle4<Vector4, 0xDE> zwyw;
- Swizzle4<Vector4, 0xDF> wwyw;
- Swizzle4<Vector4, 0xE0> xxzw;
- Swizzle4<Vector4, 0xE1> yxzw;
- Swizzle4<Vector4, 0xE2> zxzw;
- Swizzle4<Vector4, 0xE3> wxzw;
- SwizzleMask4<Vector4, 0xE4> xyzw;
- Swizzle4<Vector4, 0xE5> yyzw;
- Swizzle4<Vector4, 0xE6> zyzw;
- Swizzle4<Vector4, 0xE7> wyzw;
- Swizzle4<Vector4, 0xE8> xzzw;
- Swizzle4<Vector4, 0xE9> yzzw;
- Swizzle4<Vector4, 0xEA> zzzw;
- Swizzle4<Vector4, 0xEB> wzzw;
- Swizzle4<Vector4, 0xEC> xwzw;
- Swizzle4<Vector4, 0xED> ywzw;
- Swizzle4<Vector4, 0xEE> zwzw;
- Swizzle4<Vector4, 0xEF> wwzw;
- Swizzle4<Vector4, 0xF0> xxww;
- Swizzle4<Vector4, 0xF1> yxww;
- Swizzle4<Vector4, 0xF2> zxww;
- Swizzle4<Vector4, 0xF3> wxww;
- Swizzle4<Vector4, 0xF4> xyww;
- Swizzle4<Vector4, 0xF5> yyww;
- Swizzle4<Vector4, 0xF6> zyww;
- Swizzle4<Vector4, 0xF7> wyww;
- Swizzle4<Vector4, 0xF8> xzww;
- Swizzle4<Vector4, 0xF9> yzww;
- Swizzle4<Vector4, 0xFA> zzww;
- Swizzle4<Vector4, 0xFB> wzww;
- Swizzle4<Vector4, 0xFC> xwww;
- Swizzle4<Vector4, 0xFD> ywww;
- Swizzle4<Vector4, 0xFE> zwww;
- Swizzle4<Vector4, 0xFF> wwww;
+ SwizzleMask1<Vector4, 0x0000> x;
+ SwizzleMask1<Vector4, 0x1111> y;
+ SwizzleMask1<Vector4, 0x2222> z;
+ SwizzleMask1<Vector4, 0x3333> w;
+ Swizzle2<Vector4, 0x0000> xx;
+ Swizzle2<Vector4, 0x1000> yx;
+ Swizzle2<Vector4, 0x2000> zx;
+ Swizzle2<Vector4, 0x3000> wx;
+ SwizzleMask2<Vector4, 0x0111> xy;
+ Swizzle2<Vector4, 0x1111> yy;
+ Swizzle2<Vector4, 0x2111> zy;
+ Swizzle2<Vector4, 0x3111> wy;
+ SwizzleMask2<Vector4, 0x0222> xz;
+ SwizzleMask2<Vector4, 0x1222> yz;
+ Swizzle2<Vector4, 0x2222> zz;
+ Swizzle2<Vector4, 0x3222> wz;
+ SwizzleMask2<Vector4, 0x0333> xw;
+ SwizzleMask2<Vector4, 0x1333> yw;
+ SwizzleMask2<Vector4, 0x2333> zw;
+ Swizzle2<Vector4, 0x3333> ww;
+ Swizzle4<Vector4, 0x0000> xxx;
+ Swizzle4<Vector4, 0x1000> yxx;
+ Swizzle4<Vector4, 0x2000> zxx;
+ Swizzle4<Vector4, 0x3000> wxx;
+ Swizzle4<Vector4, 0x0100> xyx;
+ Swizzle4<Vector4, 0x1100> yyx;
+ Swizzle4<Vector4, 0x2100> zyx;
+ Swizzle4<Vector4, 0x3100> wyx;
+ Swizzle4<Vector4, 0x0200> xzx;
+ Swizzle4<Vector4, 0x1200> yzx;
+ Swizzle4<Vector4, 0x2200> zzx;
+ Swizzle4<Vector4, 0x3200> wzx;
+ Swizzle4<Vector4, 0x0300> xwx;
+ Swizzle4<Vector4, 0x1300> ywx;
+ Swizzle4<Vector4, 0x2300> zwx;
+ Swizzle4<Vector4, 0x3300> wwx;
+ Swizzle4<Vector4, 0x0011> xxy;
+ Swizzle4<Vector4, 0x1011> yxy;
+ Swizzle4<Vector4, 0x2011> zxy;
+ Swizzle4<Vector4, 0x3011> wxy;
+ Swizzle4<Vector4, 0x0111> xyy;
+ Swizzle4<Vector4, 0x1111> yyy;
+ Swizzle4<Vector4, 0x2111> zyy;
+ Swizzle4<Vector4, 0x3111> wyy;
+ Swizzle4<Vector4, 0x0211> xzy;
+ Swizzle4<Vector4, 0x1211> yzy;
+ Swizzle4<Vector4, 0x2211> zzy;
+ Swizzle4<Vector4, 0x3211> wzy;
+ Swizzle4<Vector4, 0x0311> xwy;
+ Swizzle4<Vector4, 0x1311> ywy;
+ Swizzle4<Vector4, 0x2311> zwy;
+ Swizzle4<Vector4, 0x3311> wwy;
+ Swizzle4<Vector4, 0x0022> xxz;
+ Swizzle4<Vector4, 0x1022> yxz;
+ Swizzle4<Vector4, 0x2022> zxz;
+ Swizzle4<Vector4, 0x3022> wxz;
+ SwizzleMask4<Vector4, 0x0122> xyz;
+ Swizzle4<Vector4, 0x1122> yyz;
+ Swizzle4<Vector4, 0x2122> zyz;
+ Swizzle4<Vector4, 0x3122> wyz;
+ Swizzle4<Vector4, 0x0222> xzz;
+ Swizzle4<Vector4, 0x1222> yzz;
+ Swizzle4<Vector4, 0x2222> zzz;
+ Swizzle4<Vector4, 0x3222> wzz;
+ Swizzle4<Vector4, 0x0322> xwz;
+ Swizzle4<Vector4, 0x1322> ywz;
+ Swizzle4<Vector4, 0x2322> zwz;
+ Swizzle4<Vector4, 0x3322> wwz;
+ Swizzle4<Vector4, 0x0033> xxw;
+ Swizzle4<Vector4, 0x1033> yxw;
+ Swizzle4<Vector4, 0x2033> zxw;
+ Swizzle4<Vector4, 0x3033> wxw;
+ SwizzleMask4<Vector4, 0x0133> xyw;
+ Swizzle4<Vector4, 0x1133> yyw;
+ Swizzle4<Vector4, 0x2133> zyw;
+ Swizzle4<Vector4, 0x3133> wyw;
+ SwizzleMask4<Vector4, 0x0233> xzw;
+ SwizzleMask4<Vector4, 0x1233> yzw;
+ Swizzle4<Vector4, 0x2233> zzw;
+ Swizzle4<Vector4, 0x3233> wzw;
+ Swizzle4<Vector4, 0x0333> xww;
+ Swizzle4<Vector4, 0x1333> yww;
+ Swizzle4<Vector4, 0x2333> zww;
+ Swizzle4<Vector4, 0x3333> www;
+ Swizzle4<Vector4, 0x0000> xxxx;
+ Swizzle4<Vector4, 0x1000> yxxx;
+ Swizzle4<Vector4, 0x2000> zxxx;
+ Swizzle4<Vector4, 0x3000> wxxx;
+ Swizzle4<Vector4, 0x0100> xyxx;
+ Swizzle4<Vector4, 0x1100> yyxx;
+ Swizzle4<Vector4, 0x2100> zyxx;
+ Swizzle4<Vector4, 0x3100> wyxx;
+ Swizzle4<Vector4, 0x0200> xzxx;
+ Swizzle4<Vector4, 0x1200> yzxx;
+ Swizzle4<Vector4, 0x2200> zzxx;
+ Swizzle4<Vector4, 0x3200> wzxx;
+ Swizzle4<Vector4, 0x0300> xwxx;
+ Swizzle4<Vector4, 0x1300> ywxx;
+ Swizzle4<Vector4, 0x2300> zwxx;
+ Swizzle4<Vector4, 0x3300> wwxx;
+ Swizzle4<Vector4, 0x0010> xxyx;
+ Swizzle4<Vector4, 0x1010> yxyx;
+ Swizzle4<Vector4, 0x2010> zxyx;
+ Swizzle4<Vector4, 0x3010> wxyx;
+ Swizzle4<Vector4, 0x0110> xyyx;
+ Swizzle4<Vector4, 0x1110> yyyx;
+ Swizzle4<Vector4, 0x2110> zyyx;
+ Swizzle4<Vector4, 0x3110> wyyx;
+ Swizzle4<Vector4, 0x0210> xzyx;
+ Swizzle4<Vector4, 0x1210> yzyx;
+ Swizzle4<Vector4, 0x2210> zzyx;
+ Swizzle4<Vector4, 0x3210> wzyx;
+ Swizzle4<Vector4, 0x0310> xwyx;
+ Swizzle4<Vector4, 0x1310> ywyx;
+ Swizzle4<Vector4, 0x2310> zwyx;
+ Swizzle4<Vector4, 0x3310> wwyx;
+ Swizzle4<Vector4, 0x0020> xxzx;
+ Swizzle4<Vector4, 0x1020> yxzx;
+ Swizzle4<Vector4, 0x2020> zxzx;
+ Swizzle4<Vector4, 0x3020> wxzx;
+ Swizzle4<Vector4, 0x0120> xyzx;
+ Swizzle4<Vector4, 0x1120> yyzx;
+ Swizzle4<Vector4, 0x2120> zyzx;
+ Swizzle4<Vector4, 0x3120> wyzx;
+ Swizzle4<Vector4, 0x0220> xzzx;
+ Swizzle4<Vector4, 0x1220> yzzx;
+ Swizzle4<Vector4, 0x2220> zzzx;
+ Swizzle4<Vector4, 0x3220> wzzx;
+ Swizzle4<Vector4, 0x0320> xwzx;
+ Swizzle4<Vector4, 0x1320> ywzx;
+ Swizzle4<Vector4, 0x2320> zwzx;
+ Swizzle4<Vector4, 0x3320> wwzx;
+ Swizzle4<Vector4, 0x0030> xxwx;
+ Swizzle4<Vector4, 0x1030> yxwx;
+ Swizzle4<Vector4, 0x2030> zxwx;
+ Swizzle4<Vector4, 0x3030> wxwx;
+ Swizzle4<Vector4, 0x0130> xywx;
+ Swizzle4<Vector4, 0x1130> yywx;
+ Swizzle4<Vector4, 0x2130> zywx;
+ Swizzle4<Vector4, 0x3130> wywx;
+ Swizzle4<Vector4, 0x0230> xzwx;
+ Swizzle4<Vector4, 0x1230> yzwx;
+ Swizzle4<Vector4, 0x2230> zzwx;
+ Swizzle4<Vector4, 0x3230> wzwx;
+ Swizzle4<Vector4, 0x0330> xwwx;
+ Swizzle4<Vector4, 0x1330> ywwx;
+ Swizzle4<Vector4, 0x2330> zwwx;
+ Swizzle4<Vector4, 0x3330> wwwx;
+ Swizzle4<Vector4, 0x0001> xxxy;
+ Swizzle4<Vector4, 0x1001> yxxy;
+ Swizzle4<Vector4, 0x2001> zxxy;
+ Swizzle4<Vector4, 0x3001> wxxy;
+ Swizzle4<Vector4, 0x0101> xyxy;
+ Swizzle4<Vector4, 0x1101> yyxy;
+ Swizzle4<Vector4, 0x2101> zyxy;
+ Swizzle4<Vector4, 0x3101> wyxy;
+ Swizzle4<Vector4, 0x0201> xzxy;
+ Swizzle4<Vector4, 0x1201> yzxy;
+ Swizzle4<Vector4, 0x2201> zzxy;
+ Swizzle4<Vector4, 0x3201> wzxy;
+ Swizzle4<Vector4, 0x0301> xwxy;
+ Swizzle4<Vector4, 0x1301> ywxy;
+ Swizzle4<Vector4, 0x2301> zwxy;
+ Swizzle4<Vector4, 0x3301> wwxy;
+ Swizzle4<Vector4, 0x0011> xxyy;
+ Swizzle4<Vector4, 0x1011> yxyy;
+ Swizzle4<Vector4, 0x2011> zxyy;
+ Swizzle4<Vector4, 0x3011> wxyy;
+ Swizzle4<Vector4, 0x0111> xyyy;
+ Swizzle4<Vector4, 0x1111> yyyy;
+ Swizzle4<Vector4, 0x2111> zyyy;
+ Swizzle4<Vector4, 0x3111> wyyy;
+ Swizzle4<Vector4, 0x0211> xzyy;
+ Swizzle4<Vector4, 0x1211> yzyy;
+ Swizzle4<Vector4, 0x2211> zzyy;
+ Swizzle4<Vector4, 0x3211> wzyy;
+ Swizzle4<Vector4, 0x0311> xwyy;
+ Swizzle4<Vector4, 0x1311> ywyy;
+ Swizzle4<Vector4, 0x2311> zwyy;
+ Swizzle4<Vector4, 0x3311> wwyy;
+ Swizzle4<Vector4, 0x0021> xxzy;
+ Swizzle4<Vector4, 0x1021> yxzy;
+ Swizzle4<Vector4, 0x2021> zxzy;
+ Swizzle4<Vector4, 0x3021> wxzy;
+ Swizzle4<Vector4, 0x0121> xyzy;
+ Swizzle4<Vector4, 0x1121> yyzy;
+ Swizzle4<Vector4, 0x2121> zyzy;
+ Swizzle4<Vector4, 0x3121> wyzy;
+ Swizzle4<Vector4, 0x0221> xzzy;
+ Swizzle4<Vector4, 0x1221> yzzy;
+ Swizzle4<Vector4, 0x2221> zzzy;
+ Swizzle4<Vector4, 0x3221> wzzy;
+ Swizzle4<Vector4, 0x0321> xwzy;
+ Swizzle4<Vector4, 0x1321> ywzy;
+ Swizzle4<Vector4, 0x2321> zwzy;
+ Swizzle4<Vector4, 0x3321> wwzy;
+ Swizzle4<Vector4, 0x0031> xxwy;
+ Swizzle4<Vector4, 0x1031> yxwy;
+ Swizzle4<Vector4, 0x2031> zxwy;
+ Swizzle4<Vector4, 0x3031> wxwy;
+ Swizzle4<Vector4, 0x0131> xywy;
+ Swizzle4<Vector4, 0x1131> yywy;
+ Swizzle4<Vector4, 0x2131> zywy;
+ Swizzle4<Vector4, 0x3131> wywy;
+ Swizzle4<Vector4, 0x0231> xzwy;
+ Swizzle4<Vector4, 0x1231> yzwy;
+ Swizzle4<Vector4, 0x2231> zzwy;
+ Swizzle4<Vector4, 0x3231> wzwy;
+ Swizzle4<Vector4, 0x0331> xwwy;
+ Swizzle4<Vector4, 0x1331> ywwy;
+ Swizzle4<Vector4, 0x2331> zwwy;
+ Swizzle4<Vector4, 0x3331> wwwy;
+ Swizzle4<Vector4, 0x0002> xxxz;
+ Swizzle4<Vector4, 0x1002> yxxz;
+ Swizzle4<Vector4, 0x2002> zxxz;
+ Swizzle4<Vector4, 0x3002> wxxz;
+ Swizzle4<Vector4, 0x0102> xyxz;
+ Swizzle4<Vector4, 0x1102> yyxz;
+ Swizzle4<Vector4, 0x2102> zyxz;
+ Swizzle4<Vector4, 0x3102> wyxz;
+ Swizzle4<Vector4, 0x0202> xzxz;
+ Swizzle4<Vector4, 0x1202> yzxz;
+ Swizzle4<Vector4, 0x2202> zzxz;
+ Swizzle4<Vector4, 0x3202> wzxz;
+ Swizzle4<Vector4, 0x0302> xwxz;
+ Swizzle4<Vector4, 0x1302> ywxz;
+ Swizzle4<Vector4, 0x2302> zwxz;
+ Swizzle4<Vector4, 0x3302> wwxz;
+ Swizzle4<Vector4, 0x0012> xxyz;
+ Swizzle4<Vector4, 0x1012> yxyz;
+ Swizzle4<Vector4, 0x2012> zxyz;
+ Swizzle4<Vector4, 0x3012> wxyz;
+ Swizzle4<Vector4, 0x0112> xyyz;
+ Swizzle4<Vector4, 0x1112> yyyz;
+ Swizzle4<Vector4, 0x2112> zyyz;
+ Swizzle4<Vector4, 0x3112> wyyz;
+ Swizzle4<Vector4, 0x0212> xzyz;
+ Swizzle4<Vector4, 0x1212> yzyz;
+ Swizzle4<Vector4, 0x2212> zzyz;
+ Swizzle4<Vector4, 0x3212> wzyz;
+ Swizzle4<Vector4, 0x0312> xwyz;
+ Swizzle4<Vector4, 0x1312> ywyz;
+ Swizzle4<Vector4, 0x2312> zwyz;
+ Swizzle4<Vector4, 0x3312> wwyz;
+ Swizzle4<Vector4, 0x0022> xxzz;
+ Swizzle4<Vector4, 0x1022> yxzz;
+ Swizzle4<Vector4, 0x2022> zxzz;
+ Swizzle4<Vector4, 0x3022> wxzz;
+ Swizzle4<Vector4, 0x0122> xyzz;
+ Swizzle4<Vector4, 0x1122> yyzz;
+ Swizzle4<Vector4, 0x2122> zyzz;
+ Swizzle4<Vector4, 0x3122> wyzz;
+ Swizzle4<Vector4, 0x0222> xzzz;
+ Swizzle4<Vector4, 0x1222> yzzz;
+ Swizzle4<Vector4, 0x2222> zzzz;
+ Swizzle4<Vector4, 0x3222> wzzz;
+ Swizzle4<Vector4, 0x0322> xwzz;
+ Swizzle4<Vector4, 0x1322> ywzz;
+ Swizzle4<Vector4, 0x2322> zwzz;
+ Swizzle4<Vector4, 0x3322> wwzz;
+ Swizzle4<Vector4, 0x0032> xxwz;
+ Swizzle4<Vector4, 0x1032> yxwz;
+ Swizzle4<Vector4, 0x2032> zxwz;
+ Swizzle4<Vector4, 0x3032> wxwz;
+ Swizzle4<Vector4, 0x0132> xywz;
+ Swizzle4<Vector4, 0x1132> yywz;
+ Swizzle4<Vector4, 0x2132> zywz;
+ Swizzle4<Vector4, 0x3132> wywz;
+ Swizzle4<Vector4, 0x0232> xzwz;
+ Swizzle4<Vector4, 0x1232> yzwz;
+ Swizzle4<Vector4, 0x2232> zzwz;
+ Swizzle4<Vector4, 0x3232> wzwz;
+ Swizzle4<Vector4, 0x0332> xwwz;
+ Swizzle4<Vector4, 0x1332> ywwz;
+ Swizzle4<Vector4, 0x2332> zwwz;
+ Swizzle4<Vector4, 0x3332> wwwz;
+ Swizzle4<Vector4, 0x0003> xxxw;
+ Swizzle4<Vector4, 0x1003> yxxw;
+ Swizzle4<Vector4, 0x2003> zxxw;
+ Swizzle4<Vector4, 0x3003> wxxw;
+ Swizzle4<Vector4, 0x0103> xyxw;
+ Swizzle4<Vector4, 0x1103> yyxw;
+ Swizzle4<Vector4, 0x2103> zyxw;
+ Swizzle4<Vector4, 0x3103> wyxw;
+ Swizzle4<Vector4, 0x0203> xzxw;
+ Swizzle4<Vector4, 0x1203> yzxw;
+ Swizzle4<Vector4, 0x2203> zzxw;
+ Swizzle4<Vector4, 0x3203> wzxw;
+ Swizzle4<Vector4, 0x0303> xwxw;
+ Swizzle4<Vector4, 0x1303> ywxw;
+ Swizzle4<Vector4, 0x2303> zwxw;
+ Swizzle4<Vector4, 0x3303> wwxw;
+ Swizzle4<Vector4, 0x0013> xxyw;
+ Swizzle4<Vector4, 0x1013> yxyw;
+ Swizzle4<Vector4, 0x2013> zxyw;
+ Swizzle4<Vector4, 0x3013> wxyw;
+ Swizzle4<Vector4, 0x0113> xyyw;
+ Swizzle4<Vector4, 0x1113> yyyw;
+ Swizzle4<Vector4, 0x2113> zyyw;
+ Swizzle4<Vector4, 0x3113> wyyw;
+ Swizzle4<Vector4, 0x0213> xzyw;
+ Swizzle4<Vector4, 0x1213> yzyw;
+ Swizzle4<Vector4, 0x2213> zzyw;
+ Swizzle4<Vector4, 0x3213> wzyw;
+ Swizzle4<Vector4, 0x0313> xwyw;
+ Swizzle4<Vector4, 0x1313> ywyw;
+ Swizzle4<Vector4, 0x2313> zwyw;
+ Swizzle4<Vector4, 0x3313> wwyw;
+ Swizzle4<Vector4, 0x0023> xxzw;
+ Swizzle4<Vector4, 0x1023> yxzw;
+ Swizzle4<Vector4, 0x2023> zxzw;
+ Swizzle4<Vector4, 0x3023> wxzw;
+ SwizzleMask4<Vector4, 0x0123> xyzw;
+ Swizzle4<Vector4, 0x1123> yyzw;
+ Swizzle4<Vector4, 0x2123> zyzw;
+ Swizzle4<Vector4, 0x3123> wyzw;
+ Swizzle4<Vector4, 0x0223> xzzw;
+ Swizzle4<Vector4, 0x1223> yzzw;
+ Swizzle4<Vector4, 0x2223> zzzw;
+ Swizzle4<Vector4, 0x3223> wzzw;
+ Swizzle4<Vector4, 0x0323> xwzw;
+ Swizzle4<Vector4, 0x1323> ywzw;
+ Swizzle4<Vector4, 0x2323> zwzw;
+ Swizzle4<Vector4, 0x3323> wwzw;
+ Swizzle4<Vector4, 0x0033> xxww;
+ Swizzle4<Vector4, 0x1033> yxww;
+ Swizzle4<Vector4, 0x2033> zxww;
+ Swizzle4<Vector4, 0x3033> wxww;
+ Swizzle4<Vector4, 0x0133> xyww;
+ Swizzle4<Vector4, 0x1133> yyww;
+ Swizzle4<Vector4, 0x2133> zyww;
+ Swizzle4<Vector4, 0x3133> wyww;
+ Swizzle4<Vector4, 0x0233> xzww;
+ Swizzle4<Vector4, 0x1233> yzww;
+ Swizzle4<Vector4, 0x2233> zzww;
+ Swizzle4<Vector4, 0x3233> wzww;
+ Swizzle4<Vector4, 0x0333> xwww;
+ Swizzle4<Vector4, 0x1333> ywww;
+ Swizzle4<Vector4, 0x2333> zwww;
+ Swizzle4<Vector4, 0x3333> wwww;
};
};
@@ -1945,8 +1945,8 @@
RValue<Int> Extract(RValue<Int4> val, int i);
RValue<Int4> Insert(RValue<Int4> val, RValue<Int> element, int i);
RValue<Int> SignMask(RValue<Int4> x);
- RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select);
- RValue<Int4> Blend(RValue<Int4> x, RValue<Int4> y, unsigned short select);
+ RValue<Int4> Swizzle(RValue<Int4> x, uint16_t select);
+ RValue<Int4> Blend(RValue<Int4> x, RValue<Int4> y, uint16_t select);
RValue<Int4> MulHigh(RValue<Int4> x, RValue<Int4> y);
class UInt4 : public LValue<UInt4>, public XYZW<UInt4>
@@ -2030,8 +2030,8 @@
RValue<UInt> Extract(RValue<UInt4> val, int i);
RValue<UInt4> Insert(RValue<UInt4> val, RValue<UInt> element, int i);
// RValue<UInt4> RoundInt(RValue<Float4> cast);
- RValue<UInt4> Swizzle(RValue<UInt4> x, unsigned char select);
- RValue<UInt4> Blend(RValue<UInt4> x, RValue<UInt4> y, unsigned short select);
+ RValue<UInt4> Swizzle(RValue<UInt4> x, uint16_t select);
+ RValue<UInt4> Blend(RValue<UInt4> x, RValue<UInt4> y, uint16_t select);
class Half : public LValue<Half>
{
@@ -2177,8 +2177,8 @@
// RValue<Float2> Abs(RValue<Float2> x);
// RValue<Float2> Max(RValue<Float2> x, RValue<Float2> y);
// RValue<Float2> Min(RValue<Float2> x, RValue<Float2> y);
-// RValue<Float2> Swizzle(RValue<Float2> x, unsigned char select);
-// RValue<Float2> Mask(Float2 &lhs, RValue<Float2> rhs, unsigned char select);
+// RValue<Float2> Swizzle(RValue<Float2> x, uint16_t select);
+// RValue<Float2> Mask(Float2 &lhs, RValue<Float2> rhs, uint16_t select);
class Float4 : public LValue<Float4>, public XYZW<Float4>
{
@@ -2257,12 +2257,12 @@
RValue<Float4> Sqrt(RValue<Float4> x);
RValue<Float4> Insert(RValue<Float4> val, RValue<Float> element, int i);
RValue<Float> Extract(RValue<Float4> x, int i);
- RValue<Float4> Swizzle(RValue<Float4> x, unsigned char select);
- RValue<Float4> Blend(RValue<Float4> x, RValue<Float4> y, unsigned short select);
- RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm);
+ RValue<Float4> Swizzle(RValue<Float4> x, uint16_t select);
+ RValue<Float4> Blend(RValue<Float4> x, RValue<Float4> y, uint16_t select);
+ RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, uint16_t imm);
RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y);
- RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select);
+ RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, uint16_t select);
RValue<Int> SignMask(RValue<Float4> x);
// Ordered comparison functions
@@ -2843,28 +2843,28 @@
Float4::Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
- *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
+ *this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
}
template<int X, int Y>
Float4::Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
- *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
+ *this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
}
template<int X, int Y>
Float4::Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
- *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
+ *this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
}
template<int X, int Y>
Float4::Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
- *this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
+ *this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
}
template<int T>
diff --git a/src/Reactor/ReactorUnitTests.cpp b/src/Reactor/ReactorUnitTests.cpp
index fe25a01..d76622f 100644
--- a/src/Reactor/ReactorUnitTests.cpp
+++ b/src/Reactor/ReactorUnitTests.cpp
@@ -349,6 +349,15 @@
TEST(ReactorUnitTests, Swizzle)
{
+ auto swizzleCode = [](int i) -> uint16_t
+ {
+ auto x = (i >> 0) & 0x03;
+ auto y = (i >> 2) & 0x03;
+ auto z = (i >> 4) & 0x03;
+ auto w = (i >> 6) & 0x03;
+ return (x << 12) | (y << 8) | (z << 4) | (w << 0);
+ };
+
{
FunctionT<int(void*)> function;
{
@@ -356,12 +365,12 @@
for(int i = 0; i < 256; i++)
{
- *Pointer<Float4>(out + 16 * i) = Swizzle(Float4(1.0f, 2.0f, 3.0f, 4.0f), i);
+ *Pointer<Float4>(out + 16 * i) = Swizzle(Float4(1.0f, 2.0f, 3.0f, 4.0f), swizzleCode(i));
}
for(int i = 0; i < 256; i++)
- {
- *Pointer<Float4>(out + 16 * (256 + i)) = ShuffleLowHigh(Float4(1.0f, 2.0f, 3.0f, 4.0f), Float4(5.0f, 6.0f, 7.0f, 8.0f), i);
+ {
+ *Pointer<Float4>(out + 16 * (256 + i)) = ShuffleLowHigh(Float4(1.0f, 2.0f, 3.0f, 4.0f), Float4(5.0f, 6.0f, 7.0f, 8.0f), swizzleCode(i));
}
*Pointer<Float4>(out + 16 * (512 + 0)) = UnpackLow(Float4(1.0f, 2.0f, 3.0f, 4.0f), Float4(5.0f, 6.0f, 7.0f, 8.0f));
@@ -374,13 +383,13 @@
for(int i = 0; i < 256; i++)
{
*Pointer<Short4>(out + 16 * (512 + 6) + (8 * i)) =
- Swizzle(Short4(1, 2, 3, 4), i);
+ Swizzle(Short4(1, 2, 3, 4), swizzleCode(i));
}
for(int i = 0; i < 256; i++)
{
*Pointer<Int4>(out + 16 * (512 + 6 + i) + (8 * 256)) =
- Swizzle(Int4(1, 2, 3, 4), i);
+ Swizzle(Int4(1, 2, 3, 4), swizzleCode(i));
}
Return(0);
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index 47b4b16..81409c8 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -2202,7 +2202,7 @@
pack->addArg(y.value);
::basicBlock->appendInst(pack);
- return As<SByte8>(Swizzle(As<Int4>(V(result)), 0x88));
+ return As<SByte8>(Swizzle(As<Int4>(V(result)), 0x0202));
}
}
@@ -2232,7 +2232,7 @@
pack->addArg(y.value);
::basicBlock->appendInst(pack);
- return As<Byte8>(Swizzle(As<Int4>(V(result)), 0x88));
+ return As<Byte8>(Swizzle(As<Int4>(V(result)), 0x0202));
}
}
diff --git a/src/Renderer/QuadRasterizer.cpp b/src/Renderer/QuadRasterizer.cpp
index 947a88b..a16c457 100644
--- a/src/Renderer/QuadRasterizer.cpp
+++ b/src/Renderer/QuadRasterizer.cpp
@@ -272,8 +272,8 @@
xLeft[q] = *Pointer<Short4>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline) + y * sizeof(Primitive::Span));
xRight[q] = xLeft[q];
- xLeft[q] = Swizzle(xLeft[q], 0xA0) - Short4(1, 2, 1, 2);
- xRight[q] = Swizzle(xRight[q], 0xF5) - Short4(0, 1, 0, 1);
+ xLeft[q] = Swizzle(xLeft[q], 0x0022) - Short4(1, 2, 1, 2);
+ xRight[q] = Swizzle(xRight[q], 0x1133) - Short4(0, 1, 0, 1);
}
For(Int x = x0, x < x1, x += 2)
diff --git a/src/Shader/PixelRoutine.cpp b/src/Shader/PixelRoutine.cpp
index 12040fd..31673a1 100644
--- a/src/Shader/PixelRoutine.cpp
+++ b/src/Shader/PixelRoutine.cpp
@@ -2081,8 +2081,8 @@
buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
pixel.y = *Pointer<Float4>(buffer + 8 * x, 16);
pixel.z = pixel.x;
- pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x88);
- pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0xDD);
+ pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x0202);
+ pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0x1313);
pixel.y = pixel.z;
pixel.z = pixel.w = one;
break;
