Int32x4 class

Int32x4 and operations.

Int32x4 and operations.

Int32x4 stores 4 32-bit bit-masks in "lanes". The lanes are "x", "y", "z", and "w" respectively.

Constructors

Int32x4(int x, int y, int z, int w)
Int32x4.bool(bool x, bool y, bool z, bool w)
Int32x4.fromFloat32x4Bits(Float32x4 x)

Constants

XXXX = 0x0
Mask passed to shuffle or shuffleMix.
XXXY = 0x40
XXXZ = 0x80
XXXW = 0xC0
XXYX = 0x10
XXYY = 0x50
XXYZ = 0x90
XXYW = 0xD0
XXZX = 0x20
XXZY = 0x60
XXZZ = 0xA0
XXZW = 0xE0
XXWX = 0x30
XXWY = 0x70
XXWZ = 0xB0
XXWW = 0xF0
XYXX = 0x4
XYXY = 0x44
XYXZ = 0x84
XYXW = 0xC4
XYYX = 0x14
XYYY = 0x54
XYYZ = 0x94
XYYW = 0xD4
XYZX = 0x24
XYZY = 0x64
XYZZ = 0xA4
XYZW = 0xE4
XYWX = 0x34
XYWY = 0x74
XYWZ = 0xB4
XYWW = 0xF4
XZXX = 0x8
XZXY = 0x48
XZXZ = 0x88
XZXW = 0xC8
XZYX = 0x18
XZYY = 0x58
XZYZ = 0x98
XZYW = 0xD8
XZZX = 0x28
XZZY = 0x68
XZZZ = 0xA8
XZZW = 0xE8
XZWX = 0x38
XZWY = 0x78
XZWZ = 0xB8
XZWW = 0xF8
XWXX = 0xC
XWXY = 0x4C
XWXZ = 0x8C
XWXW = 0xCC
XWYX = 0x1C
XWYY = 0x5C
XWYZ = 0x9C
XWYW = 0xDC
XWZX = 0x2C
XWZY = 0x6C
XWZZ = 0xAC
XWZW = 0xEC
XWWX = 0x3C
XWWY = 0x7C
XWWZ = 0xBC
XWWW = 0xFC
YXXX = 0x1
YXXY = 0x41
YXXZ = 0x81
YXXW = 0xC1
YXYX = 0x11
YXYY = 0x51
YXYZ = 0x91
YXYW = 0xD1
YXZX = 0x21
YXZY = 0x61
YXZZ = 0xA1
YXZW = 0xE1
YXWX = 0x31
YXWY = 0x71
YXWZ = 0xB1
YXWW = 0xF1
YYXX = 0x5
YYXY = 0x45
YYXZ = 0x85
YYXW = 0xC5
YYYX = 0x15
YYYY = 0x55
YYYZ = 0x95
YYYW = 0xD5
YYZX = 0x25
YYZY = 0x65
YYZZ = 0xA5
YYZW = 0xE5
YYWX = 0x35
YYWY = 0x75
YYWZ = 0xB5
YYWW = 0xF5
YZXX = 0x9
YZXY = 0x49
YZXZ = 0x89
YZXW = 0xC9
YZYX = 0x19
YZYY = 0x59
YZYZ = 0x99
YZYW = 0xD9
YZZX = 0x29
YZZY = 0x69
YZZZ = 0xA9
YZZW = 0xE9
YZWX = 0x39
YZWY = 0x79
YZWZ = 0xB9
YZWW = 0xF9
YWXX = 0xD
YWXY = 0x4D
YWXZ = 0x8D
YWXW = 0xCD
YWYX = 0x1D
YWYY = 0x5D
YWYZ = 0x9D
YWYW = 0xDD
YWZX = 0x2D
YWZY = 0x6D
YWZZ = 0xAD
YWZW = 0xED
YWWX = 0x3D
YWWY = 0x7D
YWWZ = 0xBD
YWWW = 0xFD
ZXXX = 0x2
ZXXY = 0x42
ZXXZ = 0x82
ZXXW = 0xC2
ZXYX = 0x12
ZXYY = 0x52
ZXYZ = 0x92
ZXYW = 0xD2
ZXZX = 0x22
ZXZY = 0x62
ZXZZ = 0xA2
ZXZW = 0xE2
ZXWX = 0x32
ZXWY = 0x72
ZXWZ = 0xB2
ZXWW = 0xF2
ZYXX = 0x6
ZYXY = 0x46
ZYXZ = 0x86
ZYXW = 0xC6
ZYYX = 0x16
ZYYY = 0x56
ZYYZ = 0x96
ZYYW = 0xD6
ZYZX = 0x26
ZYZY = 0x66
ZYZZ = 0xA6
ZYZW = 0xE6
ZYWX = 0x36
ZYWY = 0x76
ZYWZ = 0xB6
ZYWW = 0xF6
ZZXX = 0xA
ZZXY = 0x4A
ZZXZ = 0x8A
ZZXW = 0xCA
ZZYX = 0x1A
ZZYY = 0x5A
ZZYZ = 0x9A
ZZYW = 0xDA
ZZZX = 0x2A
ZZZY = 0x6A
ZZZZ = 0xAA
ZZZW = 0xEA
ZZWX = 0x3A
ZZWY = 0x7A
ZZWZ = 0xBA
ZZWW = 0xFA
ZWXX = 0xE
ZWXY = 0x4E
ZWXZ = 0x8E
ZWXW = 0xCE
ZWYX = 0x1E
ZWYY = 0x5E
ZWYZ = 0x9E
ZWYW = 0xDE
ZWZX = 0x2E
ZWZY = 0x6E
ZWZZ = 0xAE
ZWZW = 0xEE
ZWWX = 0x3E
ZWWY = 0x7E
ZWWZ = 0xBE
ZWWW = 0xFE
WXXX = 0x3
WXXY = 0x43
WXXZ = 0x83
WXXW = 0xC3
WXYX = 0x13
WXYY = 0x53
WXYZ = 0x93
WXYW = 0xD3
WXZX = 0x23
WXZY = 0x63
WXZZ = 0xA3
WXZW = 0xE3
WXWX = 0x33
WXWY = 0x73
WXWZ = 0xB3
WXWW = 0xF3
WYXX = 0x7
WYXY = 0x47
WYXZ = 0x87
WYXW = 0xC7
WYYX = 0x17
WYYY = 0x57
WYYZ = 0x97
WYYW = 0xD7
WYZX = 0x27
WYZY = 0x67
WYZZ = 0xA7
WYZW = 0xE7
WYWX = 0x37
WYWY = 0x77
WYWZ = 0xB7
WYWW = 0xF7
WZXX = 0xB
WZXY = 0x4B
WZXZ = 0x8B
WZXW = 0xCB
WZYX = 0x1B
WZYY = 0x5B
WZYZ = 0x9B
WZYW = 0xDB
WZZX = 0x2B
WZZY = 0x6B
WZZZ = 0xAB
WZZW = 0xEB
WZWX = 0x3B
WZWY = 0x7B
WZWZ = 0xBB
WZWW = 0xFB
WWXX = 0xF
WWXY = 0x4F
WWXZ = 0x8F
WWXW = 0xCF
WWYX = 0x1F
WWYY = 0x5F
WWYZ = 0x9F
WWYW = 0xDF
WWZX = 0x2F
WWZY = 0x6F
WWZZ = 0xAF
WWZW = 0xEF
WWWX = 0x3F
WWWY = 0x7F
WWWZ = 0xBF
WWWW = 0xFF

Instance Properties

x int
read-only
y int
read-only
z int
read-only
w int
read-only
signMask int
read-only
flagX bool
read-only
flagY bool
read-only
flagZ bool
read-only
flagW bool
read-only

Instance Methods

shuffle(int mask) → Int32x4
Shuffle the lane values. mask must be one of the 256 shuffle constants.
shuffleMix(Int32x4 other, int mask) → Int32x4
Shuffle the lane values in this and other. The returned Int32x4 will have XY lanes from this and ZW lanes from other. Uses the same mask as shuffle.
withX(int x) → Int32x4
Returns a new Int32x4 copied from this with a new x value.
withY(int y) → Int32x4
Returns a new Int32x4 copied from this with a new y value.
withZ(int z) → Int32x4
Returns a new Int32x4 copied from this with a new z value.
withW(int w) → Int32x4
Returns a new Int32x4 copied from this with a new w value.
withFlagX(bool x) → Int32x4
Returns a new Int32x4 copied from this with a new x value.
withFlagY(bool y) → Int32x4
Returns a new Int32x4 copied from this with a new y value.
withFlagZ(bool z) → Int32x4
Returns a new Int32x4 copied from this with a new z value.
withFlagW(bool w) → Int32x4
Returns a new Int32x4 copied from this with a new w value.
select(Float32x4 trueValue, Float32x4 falseValue) → Float32x4
Merge trueValue and falseValue based on this' bit mask: Select bit from trueValue when bit in this is on. Select bit from falseValue when bit in this is off.

Operators

operator |(Int32x4 other) → Int32x4
The bit-wise or operator.
operator &(Int32x4 other) → Int32x4
The bit-wise and operator.
operator ^(Int32x4 other) → Int32x4
The bit-wise xor operator.
operator +(Int32x4 other) → Int32x4
Addition operator.
operator -(Int32x4 other) → Int32x4
Subtraction operator.