Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
UVec4.inl
Go to the documentation of this file.
1// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
2// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
3// SPDX-License-Identifier: MIT
4
5JPH_NAMESPACE_BEGIN
6
7UVec4::UVec4(uint32 inX, uint32 inY, uint32 inZ, uint32 inW)
8{
9#if defined(JPH_USE_SSE)
10 mValue = _mm_set_epi32(int(inW), int(inZ), int(inY), int(inX));
11#elif defined(JPH_USE_NEON)
12 uint32x2_t xy = vcreate_u32(static_cast<uint64>(inX) | (static_cast<uint64>(inY) << 32));
13 uint32x2_t zw = vcreate_u32(static_cast<uint64>(inZ) | (static_cast<uint64>(inW) << 32));
14 mValue = vcombine_u32(xy, zw);
15#else
16 mU32[0] = inX;
17 mU32[1] = inY;
18 mU32[2] = inZ;
19 mU32[3] = inW;
20#endif
21}
22
23bool UVec4::operator == (UVec4Arg inV2) const
24{
25 return sEquals(*this, inV2).TestAllTrue();
26}
27
28template<uint32 SwizzleX, uint32 SwizzleY, uint32 SwizzleZ, uint32 SwizzleW>
29UVec4 UVec4::Swizzle() const
30{
31 static_assert(SwizzleX <= 3, "SwizzleX template parameter out of range");
32 static_assert(SwizzleY <= 3, "SwizzleY template parameter out of range");
33 static_assert(SwizzleZ <= 3, "SwizzleZ template parameter out of range");
34 static_assert(SwizzleW <= 3, "SwizzleW template parameter out of range");
35
36#if defined(JPH_USE_SSE)
37 return _mm_shuffle_epi32(mValue, _MM_SHUFFLE(SwizzleW, SwizzleZ, SwizzleY, SwizzleX));
38#elif defined(JPH_USE_NEON)
39 return JPH_NEON_SHUFFLE_F32x4(mValue, mValue, SwizzleX, SwizzleY, SwizzleZ, SwizzleW);
40#else
41 return UVec4(mU32[SwizzleX], mU32[SwizzleY], mU32[SwizzleZ], mU32[SwizzleW]);
42#endif
43}
44
45UVec4 UVec4::sZero()
46{
47#if defined(JPH_USE_SSE)
48 return _mm_setzero_si128();
49#elif defined(JPH_USE_NEON)
50 return vdupq_n_u32(0);
51#else
52 return UVec4(0, 0, 0, 0);
53#endif
54}
55
56UVec4 UVec4::sReplicate(uint32 inV)
57{
58#if defined(JPH_USE_SSE)
59 return _mm_set1_epi32(int(inV));
60#elif defined(JPH_USE_NEON)
61 return vdupq_n_u32(inV);
62#else
63 return UVec4(inV, inV, inV, inV);
64#endif
65}
66
67UVec4 UVec4::sLoadInt(const uint32 *inV)
68{
69#if defined(JPH_USE_SSE)
70 return _mm_castps_si128(_mm_load_ss(reinterpret_cast<const float*>(inV)));
71#elif defined(JPH_USE_NEON)
72 return vsetq_lane_u32(*inV, vdupq_n_u32(0), 0);
73#else
74 return UVec4(*inV, 0, 0, 0);
75#endif
76}
77
78UVec4 UVec4::sLoadInt4(const uint32 *inV)
79{
80#if defined(JPH_USE_SSE)
81 return _mm_loadu_si128(reinterpret_cast<const __m128i *>(inV));
82#elif defined(JPH_USE_NEON)
83 return vld1q_u32(inV);
84#else
85 return UVec4(inV[0], inV[1], inV[2], inV[3]);
86#endif
87}
88
89UVec4 UVec4::sLoadInt4Aligned(const uint32 *inV)
90{
91#if defined(JPH_USE_SSE)
92 return _mm_load_si128(reinterpret_cast<const __m128i *>(inV));
93#elif defined(JPH_USE_NEON)
94 return vld1q_u32(inV); // ARM doesn't make distinction between aligned or not
95#else
96 return UVec4(inV[0], inV[1], inV[2], inV[3]);
97#endif
98}
99
100template <const int Scale>
101UVec4 UVec4::sGatherInt4(const uint32 *inBase, UVec4Arg inOffsets)
102{
103#ifdef JPH_USE_AVX2
104 return _mm_i32gather_epi32(reinterpret_cast<const int *>(inBase), inOffsets.mValue, Scale);
105#else
106 return Vec4::sGatherFloat4<Scale>(reinterpret_cast<const float *>(inBase), inOffsets).ReinterpretAsInt();
107#endif
108}
109
110UVec4 UVec4::sMin(UVec4Arg inV1, UVec4Arg inV2)
111{
112#if defined(JPH_USE_SSE4_1)
113 return _mm_min_epu32(inV1.mValue, inV2.mValue);
114#elif defined(JPH_USE_NEON)
115 return vminq_u32(inV1.mValue, inV2.mValue);
116#else
117 UVec4 result;
118 for (int i = 0; i < 4; i++)
119 result.mU32[i] = min(inV1.mU32[i], inV2.mU32[i]);
120 return result;
121#endif
122}
123
124UVec4 UVec4::sMax(UVec4Arg inV1, UVec4Arg inV2)
125{
126#if defined(JPH_USE_SSE4_1)
127 return _mm_max_epu32(inV1.mValue, inV2.mValue);
128#elif defined(JPH_USE_NEON)
129 return vmaxq_u32(inV1.mValue, inV2.mValue);
130#else
131 UVec4 result;
132 for (int i = 0; i < 4; i++)
133 result.mU32[i] = max(inV1.mU32[i], inV2.mU32[i]);
134 return result;
135#endif
136}
137
138UVec4 UVec4::sEquals(UVec4Arg inV1, UVec4Arg inV2)
139{
140#if defined(JPH_USE_SSE)
141 return _mm_cmpeq_epi32(inV1.mValue, inV2.mValue);
142#elif defined(JPH_USE_NEON)
143 return vceqq_u32(inV1.mValue, inV2.mValue);
144#else
145 return UVec4(inV1.mU32[0] == inV2.mU32[0]? 0xffffffffu : 0,
146 inV1.mU32[1] == inV2.mU32[1]? 0xffffffffu : 0,
147 inV1.mU32[2] == inV2.mU32[2]? 0xffffffffu : 0,
148 inV1.mU32[3] == inV2.mU32[3]? 0xffffffffu : 0);
149#endif
150}
151
152UVec4 UVec4::sSelect(UVec4Arg inV1, UVec4Arg inV2, UVec4Arg inControl)
153{
154#if defined(JPH_USE_SSE4_1)
155 return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(inV1.mValue), _mm_castsi128_ps(inV2.mValue), _mm_castsi128_ps(inControl.mValue)));
156#elif defined(JPH_USE_NEON)
157 return vbslq_u32(vshrq_n_s32(inControl.mValue, 31), inV2.mValue, inV1.mValue);
158#else
159 UVec4 result;
160 for (int i = 0; i < 4; i++)
161 result.mU32[i] = inControl.mU32[i] ? inV2.mU32[i] : inV1.mU32[i];
162 return result;
163#endif
164}
165
166UVec4 UVec4::sOr(UVec4Arg inV1, UVec4Arg inV2)
167{
168#if defined(JPH_USE_SSE)
169 return _mm_or_si128(inV1.mValue, inV2.mValue);
170#elif defined(JPH_USE_NEON)
171 return vorrq_u32(inV1.mValue, inV2.mValue);
172#else
173 return UVec4(inV1.mU32[0] | inV2.mU32[0],
174 inV1.mU32[1] | inV2.mU32[1],
175 inV1.mU32[2] | inV2.mU32[2],
176 inV1.mU32[3] | inV2.mU32[3]);
177#endif
178}
179
180UVec4 UVec4::sXor(UVec4Arg inV1, UVec4Arg inV2)
181{
182#if defined(JPH_USE_SSE)
183 return _mm_xor_si128(inV1.mValue, inV2.mValue);
184#elif defined(JPH_USE_NEON)
185 return veorq_u32(inV1.mValue, inV2.mValue);
186#else
187 return UVec4(inV1.mU32[0] ^ inV2.mU32[0],
188 inV1.mU32[1] ^ inV2.mU32[1],
189 inV1.mU32[2] ^ inV2.mU32[2],
190 inV1.mU32[3] ^ inV2.mU32[3]);
191#endif
192}
193
194UVec4 UVec4::sAnd(UVec4Arg inV1, UVec4Arg inV2)
195{
196#if defined(JPH_USE_SSE)
197 return _mm_and_si128(inV1.mValue, inV2.mValue);
198#elif defined(JPH_USE_NEON)
199 return vandq_u32(inV1.mValue, inV2.mValue);
200#else
201 return UVec4(inV1.mU32[0] & inV2.mU32[0],
202 inV1.mU32[1] & inV2.mU32[1],
203 inV1.mU32[2] & inV2.mU32[2],
204 inV1.mU32[3] & inV2.mU32[3]);
205#endif
206}
207
208
209UVec4 UVec4::sNot(UVec4Arg inV1)
210{
211#if defined(JPH_USE_AVX512)
212 return _mm_ternarylogic_epi32(inV1.mValue, inV1.mValue, inV1.mValue, 0b01010101);
213#elif defined(JPH_USE_SSE)
214 return sXor(inV1, sReplicate(0xffffffff));
215#elif defined(JPH_USE_NEON)
216 return vmvnq_u32(inV1.mValue);
217#else
218 return UVec4(~inV1.mU32[0], ~inV1.mU32[1], ~inV1.mU32[2], ~inV1.mU32[3]);
219#endif
220}
221
222UVec4 UVec4::sSort4True(UVec4Arg inValue, UVec4Arg inIndex)
223{
224 // If inValue.z is false then shift W to Z
225 UVec4 v = UVec4::sSelect(inIndex.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>(), inIndex, inValue.SplatZ());
226
227 // If inValue.y is false then shift Z and further to Y and further
228 v = UVec4::sSelect(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>(), v, inValue.SplatY());
229
230 // If inValue.x is false then shift X and furhter to Y and furhter
231 v = UVec4::sSelect(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>(), v, inValue.SplatX());
232
233 return v;
234}
235
236UVec4 UVec4::operator * (UVec4Arg inV2) const
237{
238#if defined(JPH_USE_SSE4_1)
239 return _mm_mullo_epi32(mValue, inV2.mValue);
240#elif defined(JPH_USE_NEON)
241 return vmulq_u32(mValue, inV2.mValue);
242#else
243 UVec4 result;
244 for (int i = 0; i < 4; i++)
245 result.mU32[i] = mU32[i] * inV2.mU32[i];
246 return result;
247#endif
248}
249
250UVec4 UVec4::operator + (UVec4Arg inV2)
251{
252#if defined(JPH_USE_SSE)
253 return _mm_add_epi32(mValue, inV2.mValue);
254#elif defined(JPH_USE_NEON)
255 return vaddq_u32(mValue, inV2.mValue);
256#else
257 return UVec4(mU32[0] + inV2.mU32[0],
258 mU32[1] + inV2.mU32[1],
259 mU32[2] + inV2.mU32[2],
260 mU32[3] + inV2.mU32[3]);
261#endif
262}
263
264UVec4 &UVec4::operator += (UVec4Arg inV2)
265{
266#if defined(JPH_USE_SSE)
267 mValue = _mm_add_epi32(mValue, inV2.mValue);
268#elif defined(JPH_USE_NEON)
269 mValue = vaddq_u32(mValue, inV2.mValue);
270#else
271 for (int i = 0; i < 4; ++i)
272 mU32[i] += inV2.mU32[i];
273#endif
274 return *this;
275}
276
277UVec4 UVec4::SplatX() const
278{
279#if defined(JPH_USE_SSE)
280 return _mm_shuffle_epi32(mValue, _MM_SHUFFLE(0, 0, 0, 0));
281#elif defined(JPH_USE_NEON)
282 return vdupq_laneq_u32(mValue, 0);
283#else
284 return UVec4(mU32[0], mU32[0], mU32[0], mU32[0]);
285#endif
286}
287
288UVec4 UVec4::SplatY() const
289{
290#if defined(JPH_USE_SSE)
291 return _mm_shuffle_epi32(mValue, _MM_SHUFFLE(1, 1, 1, 1));
292#elif defined(JPH_USE_NEON)
293 return vdupq_laneq_u32(mValue, 1);
294#else
295 return UVec4(mU32[1], mU32[1], mU32[1], mU32[1]);
296#endif
297}
298
299UVec4 UVec4::SplatZ() const
300{
301#if defined(JPH_USE_SSE)
302 return _mm_shuffle_epi32(mValue, _MM_SHUFFLE(2, 2, 2, 2));
303#elif defined(JPH_USE_NEON)
304 return vdupq_laneq_u32(mValue, 2);
305#else
306 return UVec4(mU32[2], mU32[2], mU32[2], mU32[2]);
307#endif
308}
309
310UVec4 UVec4::SplatW() const
311{
312#if defined(JPH_USE_SSE)
313 return _mm_shuffle_epi32(mValue, _MM_SHUFFLE(3, 3, 3, 3));
314#elif defined(JPH_USE_NEON)
315 return vdupq_laneq_u32(mValue, 3);
316#else
317 return UVec4(mU32[3], mU32[3], mU32[3], mU32[3]);
318#endif
319}
320
321Vec4 UVec4::ToFloat() const
322{
323#if defined(JPH_USE_SSE)
324 return _mm_cvtepi32_ps(mValue);
325#elif defined(JPH_USE_NEON)
326 return vcvtq_f32_s32(mValue);
327#else
328 return Vec4((float)mU32[0], (float)mU32[1], (float)mU32[2], (float)mU32[3]);
329#endif
330}
331
332Vec4 UVec4::ReinterpretAsFloat() const
333{
334#if defined(JPH_USE_SSE)
335 return Vec4(_mm_castsi128_ps(mValue));
336#elif defined(JPH_USE_NEON)
337 return vreinterpretq_f32_s32(mValue);
338#else
339 return *reinterpret_cast<const Vec4 *>(this);
340#endif
341}
342
343void UVec4::StoreInt4(uint32 *outV) const
344{
345#if defined(JPH_USE_SSE)
346 _mm_storeu_si128(reinterpret_cast<__m128i *>(outV), mValue);
347#elif defined(JPH_USE_NEON)
348 vst1q_u32(outV, mValue);
349#else
350 for (int i = 0; i < 4; ++i)
351 outV[i] = mU32[i];
352#endif
353}
354
355void UVec4::StoreInt4Aligned(uint32 *outV) const
356{
357#if defined(JPH_USE_SSE)
358 _mm_store_si128(reinterpret_cast<__m128i *>(outV), mValue);
359#elif defined(JPH_USE_NEON)
360 vst1q_u32(outV, mValue); // ARM doesn't make distinction between aligned or not
361#else
362 for (int i = 0; i < 4; ++i)
363 outV[i] = mU32[i];
364#endif
365}
366
367int UVec4::CountTrues() const
368{
369#if defined(JPH_USE_SSE)
370 return CountBits(_mm_movemask_ps(_mm_castsi128_ps(mValue)));
371#elif defined(JPH_USE_NEON)
372 return vaddvq_u32(vshrq_n_u32(mValue, 31));
373#else
374 return (mU32[0] >> 31) + (mU32[1] >> 31) + (mU32[2] >> 31) + (mU32[3] >> 31);
375#endif
376}
377
378int UVec4::GetTrues() const
379{
380#if defined(JPH_USE_SSE)
381 return _mm_movemask_ps(_mm_castsi128_ps(mValue));
382#elif defined(JPH_USE_NEON)
383 int32x4_t shift = JPH_NEON_INT32x4(0, 1, 2, 3);
384 return vaddvq_u32(vshlq_u32(vshrq_n_u32(mValue, 31), shift));
385#else
386 return (mU32[0] >> 31) | ((mU32[1] >> 31) << 1) | ((mU32[2] >> 31) << 2) | ((mU32[3] >> 31) << 3);
387#endif
388}
389
390bool UVec4::TestAnyTrue() const
391{
392 return GetTrues() != 0;
393}
394
395bool UVec4::TestAnyXYZTrue() const
396{
397 return (GetTrues() & 0b111) != 0;
398}
399
400bool UVec4::TestAllTrue() const
401{
402 return GetTrues() == 0b1111;
403}
404
405bool UVec4::TestAllXYZTrue() const
406{
407 return (GetTrues() & 0b111) == 0b111;
408}
409
410template <const uint Count>
411UVec4 UVec4::LogicalShiftLeft() const
412{
413 static_assert(Count <= 31, "Invalid shift");
414
415#if defined(JPH_USE_SSE)
416 return _mm_slli_epi32(mValue, Count);
417#elif defined(JPH_USE_NEON)
418 return vshlq_n_u32(mValue, Count);
419#else
420 return UVec4(mU32[0] << Count, mU32[1] << Count, mU32[2] << Count, mU32[3] << Count);
421#endif
422}
423
424template <const uint Count>
425UVec4 UVec4::LogicalShiftRight() const
426{
427 static_assert(Count <= 31, "Invalid shift");
428
429#if defined(JPH_USE_SSE)
430 return _mm_srli_epi32(mValue, Count);
431#elif defined(JPH_USE_NEON)
432 return vshrq_n_u32(mValue, Count);
433#else
434 return UVec4(mU32[0] >> Count, mU32[1] >> Count, mU32[2] >> Count, mU32[3] >> Count);
435#endif
436}
437
438template <const uint Count>
439UVec4 UVec4::ArithmeticShiftRight() const
440{
441 static_assert(Count <= 31, "Invalid shift");
442
443#if defined(JPH_USE_SSE)
444 return _mm_srai_epi32(mValue, Count);
445#elif defined(JPH_USE_NEON)
446 return vshrq_n_s32(mValue, Count);
447#else
448 return UVec4(uint32(int32_t(mU32[0]) >> Count),
449 uint32(int32_t(mU32[1]) >> Count),
450 uint32(int32_t(mU32[2]) >> Count),
451 uint32(int32_t(mU32[3]) >> Count));
452#endif
453}
454
455UVec4 UVec4::Expand4Uint16Lo() const
456{
457#if defined(JPH_USE_SSE)
458 return _mm_unpacklo_epi16(mValue, _mm_castps_si128(_mm_setzero_ps()));
459#elif defined(JPH_USE_NEON)
460 int16x4_t value = vget_low_s16(mValue);
461 int16x4_t zero = vdup_n_s16(0);
462 return vcombine_s16(vzip1_s16(value, zero), vzip2_s16(value, zero));
463#else
464 return UVec4(mU32[0] & 0xffff,
465 (mU32[0] >> 16) & 0xffff,
466 mU32[1] & 0xffff,
467 (mU32[1] >> 16) & 0xffff);
468#endif
469}
470
471UVec4 UVec4::Expand4Uint16Hi() const
472{
473#if defined(JPH_USE_SSE)
474 return _mm_unpackhi_epi16(mValue, _mm_castps_si128(_mm_setzero_ps()));
475#elif defined(JPH_USE_NEON)
476 int16x4_t value = vget_high_s16(mValue);
477 int16x4_t zero = vdup_n_s16(0);
478 return vcombine_s16(vzip1_s16(value, zero), vzip2_s16(value, zero));
479#else
480 return UVec4(mU32[2] & 0xffff,
481 (mU32[2] >> 16) & 0xffff,
482 mU32[3] & 0xffff,
483 (mU32[3] >> 16) & 0xffff);
484#endif
485}
486
487UVec4 UVec4::Expand4Byte0() const
488{
489#if defined(JPH_USE_SSE4_1)
490 return _mm_shuffle_epi8(mValue, _mm_set_epi32(int(0xffffff03), int(0xffffff02), int(0xffffff01), int(0xffffff00)));
491#elif defined(JPH_USE_NEON)
492 int8x16_t idx = JPH_NEON_INT8x16(0x00, 0x7f, 0x7f, 0x7f, 0x01, 0x7f, 0x7f, 0x7f, 0x02, 0x7f, 0x7f, 0x7f, 0x03, 0x7f, 0x7f, 0x7f);
493 return vreinterpretq_u32_s8(vqtbl1q_s8(vreinterpretq_s8_u32(mValue), idx));
494#else
495 UVec4 result;
496 for (int i = 0; i < 4; i++)
497 result.mU32[i] = (mU32[0] >> (i * 8)) & 0xff;
498 return result;
499#endif
500}
501
502UVec4 UVec4::Expand4Byte4() const
503{
504#if defined(JPH_USE_SSE4_1)
505 return _mm_shuffle_epi8(mValue, _mm_set_epi32(int(0xffffff07), int(0xffffff06), int(0xffffff05), int(0xffffff04)));
506#elif defined(JPH_USE_NEON)
507 int8x16_t idx = JPH_NEON_INT8x16(0x04, 0x7f, 0x7f, 0x7f, 0x05, 0x7f, 0x7f, 0x7f, 0x06, 0x7f, 0x7f, 0x7f, 0x07, 0x7f, 0x7f, 0x7f);
508 return vreinterpretq_u32_s8(vqtbl1q_s8(vreinterpretq_s8_u32(mValue), idx));
509#else
510 UVec4 result;
511 for (int i = 0; i < 4; i++)
512 result.mU32[i] = (mU32[1] >> (i * 8)) & 0xff;
513 return result;
514#endif
515}
516
517UVec4 UVec4::Expand4Byte8() const
518{
519#if defined(JPH_USE_SSE4_1)
520 return _mm_shuffle_epi8(mValue, _mm_set_epi32(int(0xffffff0b), int(0xffffff0a), int(0xffffff09), int(0xffffff08)));
521#elif defined(JPH_USE_NEON)
522 int8x16_t idx = JPH_NEON_INT8x16(0x08, 0x7f, 0x7f, 0x7f, 0x09, 0x7f, 0x7f, 0x7f, 0x0a, 0x7f, 0x7f, 0x7f, 0x0b, 0x7f, 0x7f, 0x7f);
523 return vreinterpretq_u32_s8(vqtbl1q_s8(vreinterpretq_s8_u32(mValue), idx));
524#else
525 UVec4 result;
526 for (int i = 0; i < 4; i++)
527 result.mU32[i] = (mU32[2] >> (i * 8)) & 0xff;
528 return result;
529#endif
530}
531
532UVec4 UVec4::Expand4Byte12() const
533{
534#if defined(JPH_USE_SSE4_1)
535 return _mm_shuffle_epi8(mValue, _mm_set_epi32(int(0xffffff0f), int(0xffffff0e), int(0xffffff0d), int(0xffffff0c)));
536#elif defined(JPH_USE_NEON)
537 int8x16_t idx = JPH_NEON_INT8x16(0x0c, 0x7f, 0x7f, 0x7f, 0x0d, 0x7f, 0x7f, 0x7f, 0x0e, 0x7f, 0x7f, 0x7f, 0x0f, 0x7f, 0x7f, 0x7f);
538 return vreinterpretq_u32_s8(vqtbl1q_s8(vreinterpretq_s8_u32(mValue), idx));
539#else
540 UVec4 result;
541 for (int i = 0; i < 4; i++)
542 result.mU32[i] = (mU32[3] >> (i * 8)) & 0xff;
543 return result;
544#endif
545}
546
547UVec4 UVec4::ShiftComponents4Minus(int inCount) const
548{
549#if defined(JPH_USE_SSE4_1)
550 return _mm_shuffle_epi8(mValue, sFourMinusXShuffle[inCount].mValue);
551#elif defined(JPH_USE_NEON)
552 uint8x16_t idx = vreinterpretq_u8_u32(sFourMinusXShuffle[inCount].mValue);
553 return vreinterpretq_u32_s8(vqtbl1q_s8(vreinterpretq_s8_u32(mValue), idx));
554#else
555 UVec4 result = UVec4::sZero();
556 for (int i = 0; i < inCount; i++)
557 result.mU32[i] = mU32[i + 4 - inCount];
558 return result;
559#endif
560}
561
562JPH_NAMESPACE_END
uint32
uint32_t uint32
Definition Core.h:312
JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition Core.h:240
uint64
uint64_t uint64
Definition Core.h:313
JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition Core.h:234
CountBits
uint CountBits(uint32 inValue)
Count the number of 1 bits in a value.
Definition Math.h:155
SWIZZLE_Z
@ SWIZZLE_Z
Use the Z component.
Definition Swizzle.h:14
SWIZZLE_W
@ SWIZZLE_W
Use the W component.
Definition Swizzle.h:15
SWIZZLE_X
@ SWIZZLE_X
Use the X component.
Definition Swizzle.h:12
SWIZZLE_Y
@ SWIZZLE_Y
Use the Y component.
Definition Swizzle.h:13
UVec4
Definition UVec4.h:12
UVec4::Swizzle
JPH_INLINE UVec4 Swizzle() const
Swizzle the elements in inV.
UVec4::sNot
static JPH_INLINE UVec4 sNot(UVec4Arg inV1)
Logical not (component wise)
Definition UVec4.inl:209
UVec4::sMin
static JPH_INLINE UVec4 sMin(UVec4Arg inV1, UVec4Arg inV2)
Return the minimum value of each of the components.
Definition UVec4.inl:110
UVec4::LogicalShiftLeft
JPH_INLINE UVec4 LogicalShiftLeft() const
Shift all components by Count bits to the left (filling with zeros from the left)
UVec4::CountTrues
JPH_INLINE int CountTrues() const
Count the number of components that are true (true is when highest bit of component is set)
Definition UVec4.inl:367
UVec4::SplatY
JPH_INLINE UVec4 SplatY() const
Replicate the Y component to all components.
Definition UVec4.inl:288
UVec4::sLoadInt
static JPH_INLINE UVec4 sLoadInt(const uint32 *inV)
Load 1 int from memory and place it in the X component, zeros Y, Z and W.
Definition UVec4.inl:67
UVec4::Expand4Uint16Lo
JPH_INLINE UVec4 Expand4Uint16Lo() const
Takes the lower 4 16 bits and expands them to X, Y, Z and W.
Definition UVec4.inl:455
UVec4::sSort4True
static JPH_INLINE UVec4 sSort4True(UVec4Arg inValue, UVec4Arg inIndex)
Definition UVec4.inl:222
UVec4::LogicalShiftRight
JPH_INLINE UVec4 LogicalShiftRight() const
Shift all components by Count bits to the right (filling with zeros from the right)
UVec4::sReplicate
static JPH_INLINE UVec4 sReplicate(uint32 inV)
Replicate int inV across all components.
Definition UVec4.inl:56
UVec4::SplatX
JPH_INLINE UVec4 SplatX() const
Replicate the X component to all components.
Definition UVec4.inl:277
UVec4::Expand4Byte4
JPH_INLINE UVec4 Expand4Byte4() const
Takes byte 4 .. 7 and expands them to X, Y, Z and W.
Definition UVec4.inl:502
UVec4::TestAllTrue
JPH_INLINE bool TestAllTrue() const
Test if all components are true (true is when highest bit of component is set)
Definition UVec4.inl:400
UVec4::Expand4Byte0
JPH_INLINE UVec4 Expand4Byte0() const
Takes byte 0 .. 3 and expands them to X, Y, Z and W.
Definition UVec4.inl:487
UVec4::GetTrues
JPH_INLINE int GetTrues() const
Store if X is true in bit 0, Y in bit 1, Z in bit 2 and W in bit 3 (true is when highest bit of compo...
Definition UVec4.inl:378
UVec4::TestAnyXYZTrue
JPH_INLINE bool TestAnyXYZTrue() const
Test if any of X, Y or Z components are true (true is when highest bit of component is set)
Definition UVec4.inl:395
UVec4::operator+=
JPH_INLINE UVec4 & operator+=(UVec4Arg inV2)
Add two integer vectors (component wise)
Definition UVec4.inl:264
UVec4::sGatherInt4
static JPH_INLINE UVec4 sGatherInt4(const uint32 *inBase, UVec4Arg inOffsets)
Gather 4 ints from memory at inBase + inOffsets[i] * Scale.
UVec4::sAnd
static JPH_INLINE UVec4 sAnd(UVec4Arg inV1, UVec4Arg inV2)
Logical and (component wise)
Definition UVec4.inl:194
UVec4::sEquals
static JPH_INLINE UVec4 sEquals(UVec4Arg inV1, UVec4Arg inV2)
Equals (component wise)
Definition UVec4.inl:138
UVec4::sOr
static JPH_INLINE UVec4 sOr(UVec4Arg inV1, UVec4Arg inV2)
Logical or (component wise)
Definition UVec4.inl:166
UVec4::TestAllXYZTrue
JPH_INLINE bool TestAllXYZTrue() const
Test if X, Y and Z components are true (true is when highest bit of component is set)
Definition UVec4.inl:405
UVec4::ShiftComponents4Minus
JPH_INLINE UVec4 ShiftComponents4Minus(int inCount) const
Shift vector components by 4 - Count floats to the left, so if Count = 1 the resulting vector is (W,...
Definition UVec4.inl:547
UVec4::operator==
JPH_INLINE bool operator==(UVec4Arg inV2) const
Comparison.
Definition UVec4.inl:23
UVec4::sMax
static JPH_INLINE UVec4 sMax(UVec4Arg inV1, UVec4Arg inV2)
Return the maximum of each of the components.
Definition UVec4.inl:124
UVec4::SplatZ
JPH_INLINE UVec4 SplatZ() const
Replicate the Z component to all components.
Definition UVec4.inl:299
UVec4::mValue
Type mValue
Definition UVec4.h:210
UVec4::SplatW
JPH_INLINE UVec4 SplatW() const
Replicate the W component to all components.
Definition UVec4.inl:310
UVec4::StoreInt4
JPH_INLINE void StoreInt4(uint32 *outV) const
Store 4 ints to memory.
Definition UVec4.inl:343
UVec4::Expand4Byte8
JPH_INLINE UVec4 Expand4Byte8() const
Takes byte 8 .. 11 and expands them to X, Y, Z and W.
Definition UVec4.inl:517
UVec4::sLoadInt4Aligned
static JPH_INLINE UVec4 sLoadInt4Aligned(const uint32 *inV)
Load 4 ints from memory, aligned to 16 bytes.
Definition UVec4.inl:89
UVec4::sLoadInt4
static JPH_INLINE UVec4 sLoadInt4(const uint32 *inV)
Load 4 ints from memory.
Definition UVec4.inl:78
UVec4::Expand4Byte12
JPH_INLINE UVec4 Expand4Byte12() const
Takes byte 12 .. 15 and expands them to X, Y, Z and W.
Definition UVec4.inl:532
UVec4::sXor
static JPH_INLINE UVec4 sXor(UVec4Arg inV1, UVec4Arg inV2)
Logical xor (component wise)
Definition UVec4.inl:180
UVec4::Expand4Uint16Hi
JPH_INLINE UVec4 Expand4Uint16Hi() const
Takes the upper 4 16 bits and expands them to X, Y, Z and W.
Definition UVec4.inl:471
UVec4::sZero
static JPH_INLINE UVec4 sZero()
Vector with all zeros.
Definition UVec4.inl:45
UVec4::operator+
JPH_INLINE UVec4 operator+(UVec4Arg inV2)
Adds an integer value to all integer components (discards any overflow)
Definition UVec4.inl:250
UVec4::ArithmeticShiftRight
JPH_INLINE UVec4 ArithmeticShiftRight() const
Shift all components by Count bits to the right (shifting in the value of the highest bit)
UVec4::UVec4
UVec4()=default
Constructor.
UVec4::operator*
JPH_INLINE UVec4 operator*(UVec4Arg inV2) const
Multiplies each of the 4 integer components with an integer (discards any overflow)
Definition UVec4.inl:236
UVec4::sSelect
static JPH_INLINE UVec4 sSelect(UVec4Arg inV1, UVec4Arg inV2, UVec4Arg inControl)
Component wise select, returns inV1 when highest bit of inControl = 0 and inV2 when highest bit of in...
Definition UVec4.inl:152
UVec4::ToFloat
JPH_INLINE Vec4 ToFloat() const
Convert each component from an int to a float.
Definition UVec4.inl:321
UVec4::ReinterpretAsFloat
JPH_INLINE Vec4 ReinterpretAsFloat() const
Reinterpret UVec4 as a Vec4 (doesn't change the bits)
Definition UVec4.inl:332
UVec4::StoreInt4Aligned
JPH_INLINE void StoreInt4Aligned(uint32 *outV) const
Store 4 ints to memory, aligned to 16 bytes.
Definition UVec4.inl:355
UVec4::TestAnyTrue
JPH_INLINE bool TestAnyTrue() const
Test if any of the components are true (true is when highest bit of component is set)
Definition UVec4.inl:390
UVec4::mU32
uint32 mU32[4]
Definition UVec4.h:211
Vec4
Definition Vec4.h:14