1// Copyright 2009-2021 Intel Corporation
2// SPDX-License-Identifier: Apache-2.0
3
4#pragma once
5
6#define vboolf vboolf_impl
7#define vboold vboold_impl
8#define vint vint_impl
9#define vuint vuint_impl
10#define vllong vllong_impl
11#define vfloat vfloat_impl
12#define vdouble vdouble_impl
13
14namespace embree
15{
16 /* 4-wide SSE bool type */
17 template<>
18 struct vboolf<4>
19 {
20 ALIGNED_STRUCT_(16);
21
22 typedef vboolf4 Bool;
23 typedef vint4 Int;
24 typedef vfloat4 Float;
25
26 enum { size = 4 }; // number of SIMD elements
27 union { __m128 v; int i[4]; }; // data
28
29 ////////////////////////////////////////////////////////////////////////////////
30 /// Constructors, Assignment & Cast Operators
31 ////////////////////////////////////////////////////////////////////////////////
32
33 __forceinline vboolf() {}
34 __forceinline vboolf(const vboolf4& other) { v = other.v; }
35 __forceinline vboolf4& operator =(const vboolf4& other) { v = other.v; return *this; }
36
37 __forceinline vboolf(__m128 input) : v(input) {}
38 __forceinline operator const __m128&() const { return v; }
39 #if !defined(__EMSCRIPTEN__)
40 __forceinline operator const __m128i() const { return _mm_castps_si128(a: v); }
41 __forceinline operator const __m128d() const { return _mm_castps_pd(a: v); }
42 #endif
43
44 __forceinline vboolf(bool a)
45 : v(mm_lookupmask_ps[(size_t(a) << 3) | (size_t(a) << 2) | (size_t(a) << 1) | size_t(a)]) {}
46 __forceinline vboolf(bool a, bool b)
47 : v(mm_lookupmask_ps[(size_t(b) << 3) | (size_t(a) << 2) | (size_t(b) << 1) | size_t(a)]) {}
48 __forceinline vboolf(bool a, bool b, bool c, bool d)
49 : v(mm_lookupmask_ps[(size_t(d) << 3) | (size_t(c) << 2) | (size_t(b) << 1) | size_t(a)]) {}
50 __forceinline vboolf(int mask) { assert(mask >= 0 && mask < 16); v = mm_lookupmask_ps[mask]; }
51 __forceinline vboolf(unsigned int mask) { assert(mask < 16); v = mm_lookupmask_ps[mask]; }
52
53 /* return int32 mask */
54 __forceinline __m128i mask32() const {
55 return _mm_castps_si128(a: v);
56 }
57
58 ////////////////////////////////////////////////////////////////////////////////
59 /// Constants
60 ////////////////////////////////////////////////////////////////////////////////
61
62 __forceinline vboolf(FalseTy) : v(_mm_setzero_ps()) {}
63 __forceinline vboolf(TrueTy) : v(_mm_castsi128_ps(a: _mm_cmpeq_epi32(a: _mm_setzero_si128(), b: _mm_setzero_si128()))) {}
64
65 ////////////////////////////////////////////////////////////////////////////////
66 /// Array Access
67 ////////////////////////////////////////////////////////////////////////////////
68
69 __forceinline bool operator [](size_t index) const { assert(index < 4); return (_mm_movemask_ps(a: v) >> index) & 1; }
70 __forceinline int& operator [](size_t index) { assert(index < 4); return i[index]; }
71 };
72
73 ////////////////////////////////////////////////////////////////////////////////
74 /// Unary Operators
75 ////////////////////////////////////////////////////////////////////////////////
76
77 __forceinline vboolf4 operator !(const vboolf4& a) { return _mm_xor_ps(a: a, b: vboolf4(embree::True)); }
78
79 ////////////////////////////////////////////////////////////////////////////////
80 /// Binary Operators
81 ////////////////////////////////////////////////////////////////////////////////
82
83 __forceinline vboolf4 operator &(const vboolf4& a, const vboolf4& b) { return _mm_and_ps(a: a, b: b); }
84 __forceinline vboolf4 operator |(const vboolf4& a, const vboolf4& b) { return _mm_or_ps (a: a, b: b); }
85 __forceinline vboolf4 operator ^(const vboolf4& a, const vboolf4& b) { return _mm_xor_ps(a: a, b: b); }
86
87 __forceinline vboolf4 andn(const vboolf4& a, const vboolf4& b) { return _mm_andnot_ps(a: b, b: a); }
88
89 ////////////////////////////////////////////////////////////////////////////////
90 /// Assignment Operators
91 ////////////////////////////////////////////////////////////////////////////////
92
93 __forceinline vboolf4& operator &=(vboolf4& a, const vboolf4& b) { return a = a & b; }
94 __forceinline vboolf4& operator |=(vboolf4& a, const vboolf4& b) { return a = a | b; }
95 __forceinline vboolf4& operator ^=(vboolf4& a, const vboolf4& b) { return a = a ^ b; }
96
97 ////////////////////////////////////////////////////////////////////////////////
98 /// Comparison Operators + Select
99 ////////////////////////////////////////////////////////////////////////////////
100
101 __forceinline vboolf4 operator !=(const vboolf4& a, const vboolf4& b) { return _mm_xor_ps(a: a, b: b); }
102 __forceinline vboolf4 operator ==(const vboolf4& a, const vboolf4& b) { return _mm_castsi128_ps(a: _mm_cmpeq_epi32(a: a, b: b)); }
103
104 __forceinline vboolf4 select(const vboolf4& m, const vboolf4& t, const vboolf4& f) {
105#if defined(__SSE4_1__)
106 return _mm_blendv_ps(f, t, m);
107#else
108 return _mm_or_ps(a: _mm_and_ps(a: m, b: t), b: _mm_andnot_ps(a: m, b: f));
109#endif
110 }
111
112 ////////////////////////////////////////////////////////////////////////////////
113 /// Movement/Shifting/Shuffling Functions
114 ////////////////////////////////////////////////////////////////////////////////
115
116 __forceinline vboolf4 unpacklo(const vboolf4& a, const vboolf4& b) { return _mm_unpacklo_ps(a: a, b: b); }
117 __forceinline vboolf4 unpackhi(const vboolf4& a, const vboolf4& b) { return _mm_unpackhi_ps(a: a, b: b); }
118
119 template<int i0, int i1, int i2, int i3>
120 __forceinline vboolf4 shuffle(const vboolf4& v) {
121 return _mm_castsi128_ps(_mm_shuffle_epi32(v, _MM_SHUFFLE(i3, i2, i1, i0)));
122 }
123
124 template<int i0, int i1, int i2, int i3>
125 __forceinline vboolf4 shuffle(const vboolf4& a, const vboolf4& b) {
126 return _mm_shuffle_ps(a, b, _MM_SHUFFLE(i3, i2, i1, i0));
127 }
128
129 template<int i0>
130 __forceinline vboolf4 shuffle(const vboolf4& v) {
131 return shuffle<i0,i0,i0,i0>(v);
132 }
133
134#if defined(__SSE3__)
135 template<> __forceinline vboolf4 shuffle<0, 0, 2, 2>(const vboolf4& v) { return _mm_moveldup_ps(v); }
136 template<> __forceinline vboolf4 shuffle<1, 1, 3, 3>(const vboolf4& v) { return _mm_movehdup_ps(v); }
137 template<> __forceinline vboolf4 shuffle<0, 1, 0, 1>(const vboolf4& v) { return _mm_castpd_ps(_mm_movedup_pd(v)); }
138#endif
139
140#if defined(__SSE4_1__)
141 template<int dst, int src, int clr> __forceinline vboolf4 insert(const vboolf4& a, const vboolf4& b) { return _mm_insert_ps(a, b, (dst << 4) | (src << 6) | clr); }
142 template<int dst, int src> __forceinline vboolf4 insert(const vboolf4& a, const vboolf4& b) { return insert<dst, src, 0>(a, b); }
143 template<int dst> __forceinline vboolf4 insert(const vboolf4& a, const bool b) { return insert<dst, 0>(a, vboolf4(b)); }
144#endif
145
146 ////////////////////////////////////////////////////////////////////////////////
147 /// Reduction Operations
148 ////////////////////////////////////////////////////////////////////////////////
149
150 __forceinline bool reduce_and(const vboolf4& a) { return _mm_movemask_ps(a: a) == 0xf; }
151 __forceinline bool reduce_or (const vboolf4& a) { return _mm_movemask_ps(a: a) != 0x0; }
152
153 __forceinline bool all (const vboolf4& b) { return _mm_movemask_ps(a: b) == 0xf; }
154 __forceinline bool any (const vboolf4& b) { return _mm_movemask_ps(a: b) != 0x0; }
155 __forceinline bool none(const vboolf4& b) { return _mm_movemask_ps(a: b) == 0x0; }
156
157 __forceinline bool all (const vboolf4& valid, const vboolf4& b) { return all(b: (!valid) | b); }
158 __forceinline bool any (const vboolf4& valid, const vboolf4& b) { return any(b: valid & b); }
159 __forceinline bool none(const vboolf4& valid, const vboolf4& b) { return none(b: valid & b); }
160
161 __forceinline size_t movemask(const vboolf4& a) { return _mm_movemask_ps(a: a); }
162#if defined(__SSE4_2__)
163 __forceinline size_t popcnt(const vboolf4& a) { return popcnt((size_t)_mm_movemask_ps(a)); }
164#else
165 __forceinline size_t popcnt(const vboolf4& a) { return bool(a[0])+bool(a[1])+bool(a[2])+bool(a[3]); }
166#endif
167
168 ////////////////////////////////////////////////////////////////////////////////
169 /// Get/Set Functions
170 ////////////////////////////////////////////////////////////////////////////////
171
172 __forceinline bool get(const vboolf4& a, size_t index) { return a[index]; }
173 __forceinline void set(vboolf4& a, size_t index) { a[index] = -1; }
174 __forceinline void clear(vboolf4& a, size_t index) { a[index] = 0; }
175
176 ////////////////////////////////////////////////////////////////////////////////
177 /// Output Operators
178 ////////////////////////////////////////////////////////////////////////////////
179
180 __forceinline embree_ostream operator <<(embree_ostream cout, const vboolf4& a) {
181 return cout << "<" << a[0] << ", " << a[1] << ", " << a[2] << ", " << a[3] << ">";
182 }
183}
184
185#undef vboolf
186#undef vboold
187#undef vint
188#undef vuint
189#undef vllong
190#undef vfloat
191#undef vdouble
192

source code of qtquick3d/src/3rdparty/embree/common/simd/vboolf4_sse2.h