Blender V5.3
gpu_shader_cxx_vector.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#pragma once
12
13/* Implement type_trait manually to avoid dragging compile time down. */
14namespace cxx {
15
16template<typename T, typename U> struct is_same {
17 static constexpr bool value = false;
18};
19template<typename T> struct is_same<T, T> {
20 static constexpr bool value = true;
21};
22template<typename T, typename U> inline constexpr bool is_same_v = is_same<T, U>::value;
23template<typename T> struct is_integral_base {
24 static constexpr bool value = false;
25};
26
27// Helper macro to stamp out the true cases quickly
28#define REGISTER_INTEGRAL(TYPE) \
29 template<> struct is_integral_base<TYPE> { \
30 static constexpr bool value = true; \
31 };
32
34REGISTER_INTEGRAL(signed char)
35REGISTER_INTEGRAL(unsigned char)
37REGISTER_INTEGRAL(unsigned short)
39REGISTER_INTEGRAL(unsigned int)
41REGISTER_INTEGRAL(unsigned long)
42REGISTER_INTEGRAL(long long)
43REGISTER_INTEGRAL(unsigned long long)
44
45template<typename T> inline constexpr bool is_integral_v = is_integral_base<T>::value;
46} // namespace cxx
47
48#undef REGISTER_INTEGRAL
49
50/* Some compilers complain about lack of return values. Keep it short. */
51#define RET \
52 { \
53 return {}; \
54 }
55
56template<typename T>
58
59template<typename T>
61
62/* -------------------------------------------------------------------- */
65
66template<typename T, int Sz> struct VecBase {};
67
68template<typename T, int Sz> struct VecOp {
70
71 const T &operator[](int) const
72 {
73 return *reinterpret_cast<const T *>(this);
74 }
75 const T &operator[](unsigned int) const
76 {
77 return *reinterpret_cast<const T *>(this);
78 }
80 {
81 return *reinterpret_cast<T *>(this);
82 }
83 T &operator[](unsigned int)
84 {
85 return *reinterpret_cast<T *>(this);
86 }
87
88#define STD_OP requires NotBool<T>
89
91 VecT operator-() const STD_OP RET;
92
93 friend VecT operator+(VecT, VecT) STD_OP RET;
94 friend VecT operator-(VecT, VecT) STD_OP RET;
95 friend VecT operator/(VecT, VecT) STD_OP RET;
96 friend VecT operator*(VecT, VecT) STD_OP RET;
97
98 friend VecT operator+(VecT, T) STD_OP RET;
99 friend VecT operator-(VecT, T) STD_OP RET;
100 friend VecT operator/(VecT, T) STD_OP RET;
101 friend VecT operator*(VecT, T) STD_OP RET;
102
103 friend VecT operator+(T, VecT) STD_OP RET;
104 friend VecT operator-(T, VecT) STD_OP RET;
105 friend VecT operator/(T, VecT) STD_OP RET;
106 friend VecT operator*(T, VecT) STD_OP RET;
107
108 friend VecT operator+=(VecOp &, VecT) STD_OP RET;
109 friend VecT operator-=(VecOp &, VecT) STD_OP RET;
110 friend VecT operator/=(VecOp &, VecT) STD_OP RET;
111 friend VecT operator*=(VecOp &, VecT) STD_OP RET;
112
113 friend VecT operator+=(VecOp &, T) STD_OP RET;
114 friend VecT operator-=(VecOp &, T) STD_OP RET;
115 friend VecT operator/=(VecOp &, T) STD_OP RET;
116 friend VecT operator*=(VecOp &, T) STD_OP RET;
117
118#undef STD_OP
119
120#define INT_OP requires IsIntegral<T>
121
123
128
133
138
143
148
153
158
163
164#undef INT_OP
165};
166
167template<typename T, int Sz> struct SwizzleBase : VecOp<T, Sz> {
169
170 SwizzleBase() = default;
172
173 constexpr VecT operator=(const VecT &) RET;
174 operator VecT() const RET;
175 operator VecT() RET;
176 VecT operator()() const RET;
177};
178
179#define SWIZZLE_XY(T) \
180 SwizzleBase<T, 2> xx, xy, yx, yy; \
181 SwizzleBase<T, 3> xxx, xxy, xyx, xyy, yxx, yxy, yyx, yyy; \
182 SwizzleBase<T, 4> xxxx, xxxy, xxyx, xxyy, xyxx, xyxy, xyyx, xyyy, yxxx, yxxy, yxyx, yxyy, yyxx, \
183 yyxy, yyyx, yyyy;
184
185#define SWIZZLE_RG(T) \
186 SwizzleBase<T, 2> rr, rg, gr, gg; \
187 SwizzleBase<T, 3> rrr, rrg, rgr, rgg, grr, grg, ggr, ggg; \
188 SwizzleBase<T, 4> rrrr, rrrg, rrgr, rrgg, rgrr, rgrg, rggr, rggg, grrr, grrg, grgr, grgg, ggrr, \
189 ggrg, gggr, gggg;
190
191#define SWIZZLE_XYZ(T) \
192 SWIZZLE_XY(T) \
193 SwizzleBase<T, 2> xz, yz, zx, zy, zz; \
194 SwizzleBase<T, 3> xxz, xyz, xzx, xzy, xzz, yxz, yyz, yzx, yzy, yzz, zxx, zxy, zxz, zyx, zyy, \
195 zyz, zzx, zzy, zzz; \
196 SwizzleBase<T, 4> xxxz, xxyz, xxzx, xxzy, xxzz, xyxz, xyyz, xyzx, xyzy, xyzz, xzxx, xzxy, xzxz, \
197 xzyx, xzyy, xzyz, xzzx, xzzy, xzzz, yxxz, yxyz, yxzx, yxzy, yxzz, yyxz, yyyz, yyzx, yyzy, \
198 yyzz, yzxx, yzxy, yzxz, yzyx, yzyy, yzyz, yzzx, yzzy, yzzz, zxxx, zxxy, zxxz, zxyx, zxyy, \
199 zxyz, zxzx, zxzy, zxzz, zyxx, zyxy, zyxz, zyyx, zyyy, zyyz, zyzx, zyzy, zyzz, zzxx, zzxy, \
200 zzxz, zzyx, zzyy, zzyz, zzzx, zzzy, zzzz;
201
202#define SWIZZLE_RGB(T) \
203 SWIZZLE_RG(T) \
204 SwizzleBase<T, 2> rb, gb, br, bg, bb; \
205 SwizzleBase<T, 3> rrb, rgb, rbr, rbg, rbb, grb, ggb, gbr, gbg, gbb, brr, brg, brb, bgr, bgg, \
206 bgb, bbr, bbg, bbb; \
207 SwizzleBase<T, 4> rrrb, rrgb, rrbr, rrbg, rrbb, rgrb, rggb, rgbr, rgbg, rgbb, rbrr, rbrg, rbrb, \
208 rbgr, rbgg, rbgb, rbbr, rbbg, rbbb, grrb, grgb, grbr, grbg, grbb, ggrb, gggb, ggbr, ggbg, \
209 ggbb, gbrr, gbrg, gbrb, gbgr, gbgg, gbgb, gbbr, gbbg, gbbb, brrr, brrg, brrb, brgr, brgg, \
210 brgb, brbr, brbg, brbb, bgrr, bgrg, bgrb, bggr, bggg, bggb, bgbr, bgbg, bgbb, bbrr, bbrg, \
211 bbrb, bbgr, bbgg, bbgb, bbbr, bbbg, bbbb;
212
213#define SWIZZLE_XYZW(T) \
214 SWIZZLE_XYZ(T) \
215 SwizzleBase<T, 2> xw, yw, zw, wx, wy, wz, ww; \
216 SwizzleBase<T, 3> xxw, xyw, xzw, xwx, xwy, xwz, xww, yxw, yyw, yzw, ywx, ywy, ywz, yww, zxw, \
217 zyw, zzw, zwx, zwy, zwz, zww, wxx, wxy, wxz, wxw, wyx, wyy, wyz, wyw, wzx, wzy, wzz, wzw, \
218 wwx, wwy, wwz, www; \
219 SwizzleBase<T, 4> xxxw, xxyw, xxzw, xxwx, xxwy, xxwz, xxww, xyxw, xyyw, xyzw, xywx, xywy, xywz, \
220 xyww, xzxw, xzyw, xzzw, xzwx, xzwy, xzwz, xzww, xwxx, xwxy, xwxz, xwxw, xwyx, xwyy, xwyz, \
221 xwyw, xwzx, xwzy, xwzz, xwzw, xwwx, xwwy, xwwz, xwww, yxxw, yxyw, yxzw, yxwx, yxwy, yxwz, \
222 yxww, yyxw, yyyw, yyzw, yywx, yywy, yywz, yyww, yzxw, yzyw, yzzw, yzwx, yzwy, yzwz, yzww, \
223 ywxx, ywxy, ywxz, ywxw, ywyx, ywyy, ywyz, ywyw, ywzx, ywzy, ywzz, ywzw, ywwx, ywwy, ywwz, \
224 ywww, zxxw, zxyw, zxzw, zxwx, zxwy, zxwz, zxww, zyxw, zyyw, zyzw, zywx, zywy, zywz, zyww, \
225 zzxw, zzyw, zzzw, zzwx, zzwy, zzwz, zzww, zwxx, zwxy, zwxz, zwxw, zwyx, zwyy, zwyz, zwyw, \
226 zwzx, zwzy, zwzz, zwzw, zwwx, zwwy, zwwz, zwww, wxxx, wxxy, wxxz, wxxw, wxyx, wxyy, wxyz, \
227 wxyw, wxzx, wxzy, wxzz, wxzw, wxwx, wxwy, wxwz, wxww, wyxx, wyxy, wyxz, wyxw, wyyx, wyyy, \
228 wyyz, wyyw, wyzx, wyzy, wyzz, wyzw, wywx, wywy, wywz, wyww, wzxx, wzxy, wzxz, wzxw, wzyx, \
229 wzyy, wzyz, wzyw, wzzx, wzzy, wzzz, wzzw, wzwx, wzwy, wzwz, wzww, wwxx, wwxy, wwxz, wwxw, \
230 wwyx, wwyy, wwyz, wwyw, wwzx, wwzy, wwzz, wwzw, wwwx, wwwy, wwwz, wwww;
231
232#define SWIZZLE_RGBA(T) \
233 SWIZZLE_RGB(T) \
234 SwizzleBase<T, 2> ra, ga, ba, ar, ag, ab, aa; \
235 SwizzleBase<T, 3> rra, rga, rba, rar, rag, rab, raa, gra, gga, gba, gar, gag, gab, gaa, bra, \
236 bga, bba, bar, bag, bab, baa, arr, arg, arb, ara, agr, agg, agb, aga, abr, abg, abb, aba, \
237 aar, aag, aab, aaa; \
238 SwizzleBase<T, 4> rrra, rrga, rrba, rrar, rrag, rrab, rraa, rgra, rgga, rgba, rgar, rgag, rgab, \
239 rgaa, rbra, rbga, rbba, rbar, rbag, rbab, rbaa, rarr, rarg, rarb, rara, ragr, ragg, ragb, \
240 raga, rabr, rabg, rabb, raba, raar, raag, raab, raaa, grra, grga, grba, grar, grag, grab, \
241 graa, ggra, ggga, ggba, ggar, ggag, ggab, ggaa, gbra, gbga, gbba, gbar, gbag, gbab, gbaa, \
242 garr, garg, garb, gara, gagr, gagg, gagb, gaga, gabr, gabg, gabb, gaba, gaar, gaag, gaab, \
243 gaaa, brra, brga, brba, brar, brag, brab, braa, bgra, bgga, bgba, bgar, bgag, bgab, bgaa, \
244 bbra, bbga, bbba, bbar, bbag, bbab, bbaa, barr, barg, barb, bara, bagr, bagg, bagb, baga, \
245 babr, babg, babb, baba, baar, baag, baab, baaa, arrr, arrg, arrb, arra, argr, argg, argb, \
246 arga, arbr, arbg, arbb, arba, arar, arag, arab, araa, agrr, agrg, agrb, agra, aggr, aggg, \
247 aggb, agga, agbr, agbg, agbb, agba, agar, agag, agab, agaa, abrr, abrg, abrb, abra, abgr, \
248 abgg, abgb, abga, abbr, abbg, abbb, abba, abar, abag, abab, abaa, aarr, aarg, aarb, aara, \
249 aagr, aagg, aagb, aaga, aabr, aabg, aabb, aaba, aaar, aaag, aaab, aaaa;
250
251template<typename T> struct VecBase<T, 1> {
252 VecBase() = default;
253 template<typename U> explicit VecBase(VecOp<U, 1>) {}
255
256 operator T() RET;
257};
258
259template<typename T> struct VecBase<T, 2> : VecOp<T, 2> {
260 private:
261 /* Weird non-zero value to avoid error about division by zero in constexpr. */
262 static constexpr T V = T(0.123f);
263
264 public:
265 union {
266 struct {
267 T x, y;
268 };
269 struct {
270 T r, g;
271 };
272 SWIZZLE_XY(T);
273 SWIZZLE_RG(T);
274 };
275
276 VecBase() = default;
277 template<typename U> explicit VecBase(VecOp<U, 2>) {}
278 constexpr explicit VecBase(T) : x(V), y(V) {}
279 /* Implemented correctly for GCC to compile the constexpr float2 arrays. */
280 constexpr explicit VecBase(T x_, T y_) : x(x_), y(y_) {}
281};
282
283template<typename T> struct VecBase<T, 3> : VecOp<T, 3> {
284 private:
285 /* Weird non-zero value to avoid error about division by zero in constexpr. */
286 static constexpr T V = T(0.123f);
287
288 public:
289 union {
290 struct {
291 T x, y, z;
292 };
293 struct {
294 T r, g, b;
295 };
296 SWIZZLE_XYZ(T);
297 SWIZZLE_RGB(T);
298 };
299
300 VecBase() = default;
301 template<typename U> explicit VecBase(VecOp<U, 3>) {}
302 constexpr explicit VecBase(T) : x(V), y(V), z(V) {}
303 /* Implemented correctly for GCC to compile the constexpr gl_WorkGroupSize. */
304 constexpr explicit VecBase(T x_, T y_, T z_) : x(x_), y(y_), z(z_) {}
305 constexpr explicit VecBase(VecOp<T, 2>, T) : x(V), y(V), z(V) {}
306 constexpr explicit VecBase(T, VecOp<T, 2>) : x(V), y(V), z(V) {}
307};
308
309template<typename T> struct VecBase<T, 4> : VecOp<T, 4> {
310 private:
311 /* Weird non-zero value to avoid error about division by zero in constexpr. */
312 static constexpr T V = T(0.123f);
313
314 public:
315 union {
316 struct {
317 T x, y, z, w;
318 };
319 struct {
320 T r, g, b, a;
321 };
324 };
325
326 VecBase() = default;
327 template<typename U> explicit VecBase(VecOp<U, 4>) {}
328 constexpr explicit VecBase(T) : x(V), y(V), z(V), w(V) {}
329 /* Implemented correctly for GCC to compile the constexpr. */
330 constexpr explicit VecBase(T x_, T y_, T z_, T w_) : x(x_), y(y_), z(z_), w(w_) {}
331 constexpr explicit VecBase(VecOp<T, 2>, T, T) : x(V), y(V), z(V), w(V) {}
332 constexpr explicit VecBase(T, VecOp<T, 2>, T) : x(V), y(V), z(V), w(V) {}
333 constexpr explicit VecBase(T, T, VecOp<T, 2>) : x(V), y(V), z(V), w(V) {}
334 constexpr explicit VecBase(VecOp<T, 2>, VecOp<T, 2>) : x(V), y(V), z(V), w(V) {}
335 constexpr explicit VecBase(VecOp<T, 3>, T) : x(V), y(V), z(V), w(V) {}
336 constexpr explicit VecBase(T, VecOp<T, 3>) : x(V), y(V), z(V), w(V) {}
337};
338
339/* Boolean vectors do not have operators and are not convertible from other types. */
340
341template<> struct VecBase<bool, 2> : VecOp<bool, 2> {
342 union {
343 struct {
344 bool x, y;
345 };
346 SWIZZLE_XY(bool);
347 };
348
349 VecBase() = default;
350 explicit VecBase(bool) {}
351 explicit VecBase(bool, bool) {}
352 /* Should be forbidden, but is used by SMAA. */
354};
355
356template<> struct VecBase<bool, 3> : VecOp<bool, 3> {
357 union {
358 struct {
359 bool x, y, z;
360 };
361 SWIZZLE_XYZ(bool);
362 };
363
364 VecBase() = default;
365 explicit VecBase(bool) {}
366 explicit VecBase(bool, bool, bool) {}
367 explicit VecBase(VecOp<bool, 2>, bool) {}
368 explicit VecBase(bool, VecOp<bool, 2>) {}
369};
370
371template<> struct VecBase<bool, 4> : VecOp<bool, 4> {
372 union {
373 struct {
374 bool x, y, z, w;
375 };
376 SWIZZLE_XYZW(bool);
377 };
378
379 VecBase() = default;
380 explicit VecBase(bool) {}
381 explicit VecBase(bool, bool, bool, bool) {}
382 explicit VecBase(VecOp<bool, 2>, bool, bool) {}
383 explicit VecBase(bool, VecOp<bool, 2>, bool) {}
384 explicit VecBase(bool, bool, VecOp<bool, 2>) {}
386 explicit VecBase(VecOp<bool, 3>, bool) {}
387 explicit VecBase(bool, VecOp<bool, 3>) {}
388};
389
390using uint = unsigned int;
391using uint32_t = unsigned int; /* For typed enums. */
392
396
400
404
405using uchar = unsigned int;
409
413
414using ushort = unsigned short;
418
422
423using half = float;
427
431
432using bool32_t = uint;
433
444
446
447#undef RET
int32_t bool32_t
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
Definition half.h:29
unsigned int uchar
int2 packed_int2
VecBase< ushort, 2 > ushort2
VecBase< short, 4 > short4
VecBase< short, 2 > short2
float2 packed_float2
#define INT_OP
VecBase< bool, 4 > bool4
VecBase< char, 3 > char3
#define REGISTER_INTEGRAL(TYPE)
#define SWIZZLE_RGBA(T)
VecBase< bool, 3 > bool3
uint4 packed_uint4
VecBase< ushort, 3 > ushort3
VecBase< half, 2 > half2
#define SWIZZLE_RGB(T)
VecBase< char, 2 > char2
VecBase< short, 3 > short3
#define RET
VecBase< half, 3 > half3
VecBase< bool, 2 > bool2
int4 packed_int4
#define SWIZZLE_XYZW(T)
uint2 packed_uint2
#define SWIZZLE_XYZ(T)
VecBase< char, 4 > char4
#define SWIZZLE_RG(T)
#define STD_OP
#define SWIZZLE_XY(T)
#define T
unsigned int uint
Definition BKE_text.h:55
unsigned int uint32_t
Definition BKE_text.h:81
constexpr bool is_same_v
constexpr bool is_integral_v
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
constexpr VecT operator=(const VecT &) RET
SwizzleBase()=default
VecBase< T, Sz > VecT
VecBase()=default
VecBase()=default
constexpr VecBase(T x_, T y_)
constexpr VecBase(T, VecOp< T, 2 >)
constexpr VecBase(T x_, T y_, T z_)
VecBase()=default
constexpr VecBase(VecOp< T, 2 >, T)
constexpr VecBase(VecOp< T, 3 >, T)
constexpr VecBase(T x_, T y_, T z_, T w_)
constexpr VecBase(VecOp< T, 2 >, T, T)
VecBase()=default
constexpr VecBase(T, T, VecOp< T, 2 >)
constexpr VecBase(T, VecOp< T, 2 >, T)
constexpr VecBase(T, VecOp< T, 3 >)
constexpr VecBase(VecOp< T, 2 >, VecOp< T, 2 >)
VecBase(VecOp< float, 2 >)
VecBase(VecOp< bool, 2 >, bool)
VecBase(bool, VecOp< bool, 2 >)
VecBase(bool, bool, VecOp< bool, 2 >)
VecBase(bool, VecOp< bool, 2 >, bool)
VecBase(VecOp< bool, 2 >, VecOp< bool, 2 >)
VecBase(bool, VecOp< bool, 3 >)
VecBase(VecOp< bool, 3 >, bool)
VecBase(bool, bool, bool, bool)
VecBase(VecOp< bool, 2 >, bool, bool)
T & operator[](int)
friend VecT operator%(T, VecT) INT_OP RET
friend VecT operator%=(VecOp &, VecT) INT_OP RET
const T & operator[](unsigned int) const
friend VecT operator&=(VecOp &, VecT) INT_OP RET
friend VecT operator>>(VecT, VecT) INT_OP RET
friend VecT operator^=(VecOp &, VecT) INT_OP RET
friend VecT operator%(VecT, VecT) INT_OP RET
VecT operator+() const STD_OP RET
friend VecT operator>>=(VecOp &, T) INT_OP RET
friend VecT operator~(VecT) INT_OP RET
friend VecT operator<<(VecT, VecT) INT_OP RET
friend VecT operator<<=(VecOp &, T) INT_OP RET
friend VecT operator<<(T, VecT) INT_OP RET
friend VecT operator^=(VecOp &, T) INT_OP RET
friend VecT operator>>=(T &, VecT) INT_OP RET
T & operator[](unsigned int)
friend VecT operator%(VecT, T) INT_OP RET
friend VecT operator^(VecT, VecT) INT_OP RET
VecBase< T, Sz > VecT
friend VecT operator>>(T, VecT) INT_OP RET
friend VecT operator<<=(T &, VecT) INT_OP RET
friend VecT operator&(T, VecT) INT_OP RET
friend VecT operator|=(VecOp &, T) INT_OP RET
friend VecT operator>>(VecT, T) INT_OP RET
friend VecT operator|=(VecOp &, VecT) INT_OP RET
friend VecT operator%=(VecOp &, T) INT_OP RET
friend VecT operator|(VecT, T) INT_OP RET
friend VecT operator&(VecT, T) INT_OP RET
friend VecT operator>>=(VecOp &, VecT) INT_OP RET
friend VecT operator^(T, VecT) INT_OP RET
const T & operator[](int) const
friend VecT operator<<=(VecOp &, VecT) INT_OP RET
friend VecT operator<<(VecT, T) INT_OP RET
friend VecT operator|(T, VecT) INT_OP RET
friend VecT operator|(VecT, VecT) INT_OP RET
friend VecT operator&=(VecOp &, T) INT_OP RET
friend VecT operator&(VecT, VecT) INT_OP RET
friend VecT operator^(VecT, T) INT_OP RET
static constexpr bool value
static constexpr bool value
static constexpr bool value
Definition half.h:53