suwako / VulkanExample

master
ブランチ master
VulkanExample / dep / include / glm / gtc / bitfield.inl
20.5 KB、635行 生 Blame 履歴
1/// @ref gtc_bitfield
2
3#include "../simd/integer.h"
4
5namespace glm{
6namespace detail
7{
8 template<typename PARAM, typename RET>
9 GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
10
11 template<typename PARAM, typename RET>
12 GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
13
14 template<typename PARAM, typename RET>
15 GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
16
17 template<>
18 GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
19 {
20 glm::uint16 REG1(x);
21 glm::uint16 REG2(y);
22
23 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint16>(0x0F0F);
24 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint16>(0x0F0F);
25
26 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint16>(0x3333);
27 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint16>(0x3333);
28
29 REG1 = ((REG1 << 1) | REG1) & static_cast<glm::uint16>(0x5555);
30 REG2 = ((REG2 << 1) | REG2) & static_cast<glm::uint16>(0x5555);
31
32 return REG1 | static_cast<glm::uint16>(REG2 << 1);
33 }
34
35 template<>
36 GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
37 {
38 glm::uint32 REG1(x);
39 glm::uint32 REG2(y);
40
41 REG1 = ((REG1 << 8) | REG1) & static_cast<glm::uint32>(0x00FF00FF);
42 REG2 = ((REG2 << 8) | REG2) & static_cast<glm::uint32>(0x00FF00FF);
43
44 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint32>(0x0F0F0F0F);
45 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint32>(0x0F0F0F0F);
46
47 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint32>(0x33333333);
48 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint32>(0x33333333);
49
50 REG1 = ((REG1 << 1) | REG1) & static_cast<glm::uint32>(0x55555555);
51 REG2 = ((REG2 << 1) | REG2) & static_cast<glm::uint32>(0x55555555);
52
53 return REG1 | (REG2 << 1);
54 }
55
56 template<>
57 GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
58 {
59 glm::uint64 REG1(x);
60 glm::uint64 REG2(y);
61
62 REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
63 REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
64
65 REG1 = ((REG1 << 8) | REG1) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
66 REG2 = ((REG2 << 8) | REG2) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
67
68 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
69 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
70
71 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint64>(0x3333333333333333ull);
72 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint64>(0x3333333333333333ull);
73
74 REG1 = ((REG1 << 1) | REG1) & static_cast<glm::uint64>(0x5555555555555555ull);
75 REG2 = ((REG2 << 1) | REG2) & static_cast<glm::uint64>(0x5555555555555555ull);
76
77 return REG1 | (REG2 << 1);
78 }
79
80 template<>
81 GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)
82 {
83 glm::uint32 REG1(x);
84 glm::uint32 REG2(y);
85 glm::uint32 REG3(z);
86
87 REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint32>(0xFF0000FFu);
88 REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint32>(0xFF0000FFu);
89 REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint32>(0xFF0000FFu);
90
91 REG1 = ((REG1 << 8) | REG1) & static_cast<glm::uint32>(0x0F00F00Fu);
92 REG2 = ((REG2 << 8) | REG2) & static_cast<glm::uint32>(0x0F00F00Fu);
93 REG3 = ((REG3 << 8) | REG3) & static_cast<glm::uint32>(0x0F00F00Fu);
94
95 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint32>(0xC30C30C3u);
96 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint32>(0xC30C30C3u);
97 REG3 = ((REG3 << 4) | REG3) & static_cast<glm::uint32>(0xC30C30C3u);
98
99 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint32>(0x49249249u);
100 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint32>(0x49249249u);
101 REG3 = ((REG3 << 2) | REG3) & static_cast<glm::uint32>(0x49249249u);
102
103 return REG1 | (REG2 << 1) | (REG3 << 2);
104 }
105
106 template<>
107 GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)
108 {
109 glm::uint64 REG1(x);
110 glm::uint64 REG2(y);
111 glm::uint64 REG3(z);
112
113 REG1 = ((REG1 << 32) | REG1) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
114 REG2 = ((REG2 << 32) | REG2) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
115 REG3 = ((REG3 << 32) | REG3) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
116
117 REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
118 REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
119 REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
120
121 REG1 = ((REG1 << 8) | REG1) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
122 REG2 = ((REG2 << 8) | REG2) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
123 REG3 = ((REG3 << 8) | REG3) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
124
125 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
126 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
127 REG3 = ((REG3 << 4) | REG3) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
128
129 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint64>(0x9249249249249249ull);
130 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint64>(0x9249249249249249ull);
131 REG3 = ((REG3 << 2) | REG3) & static_cast<glm::uint64>(0x9249249249249249ull);
132
133 return REG1 | (REG2 << 1) | (REG3 << 2);
134 }
135
136 template<>
137 GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
138 {
139 glm::uint64 REG1(x);
140 glm::uint64 REG2(y);
141 glm::uint64 REG3(z);
142
143 REG1 = ((REG1 << 32) | REG1) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
144 REG2 = ((REG2 << 32) | REG2) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
145 REG3 = ((REG3 << 32) | REG3) & static_cast<glm::uint64>(0xFFFF00000000FFFFull);
146
147 REG1 = ((REG1 << 16) | REG1) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
148 REG2 = ((REG2 << 16) | REG2) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
149 REG3 = ((REG3 << 16) | REG3) & static_cast<glm::uint64>(0x00FF0000FF0000FFull);
150
151 REG1 = ((REG1 << 8) | REG1) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
152 REG2 = ((REG2 << 8) | REG2) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
153 REG3 = ((REG3 << 8) | REG3) & static_cast<glm::uint64>(0xF00F00F00F00F00Full);
154
155 REG1 = ((REG1 << 4) | REG1) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
156 REG2 = ((REG2 << 4) | REG2) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
157 REG3 = ((REG3 << 4) | REG3) & static_cast<glm::uint64>(0x30C30C30C30C30C3ull);
158
159 REG1 = ((REG1 << 2) | REG1) & static_cast<glm::uint64>(0x9249249249249249ull);
160 REG2 = ((REG2 << 2) | REG2) & static_cast<glm::uint64>(0x9249249249249249ull);
161 REG3 = ((REG3 << 2) | REG3) & static_cast<glm::uint64>(0x9249249249249249ull);
162
163 return REG1 | (REG2 << 1) | (REG3 << 2);
164 }
165
166 template<>
167 GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
168 {
169 glm::uint32 REG1(x);
170 glm::uint32 REG2(y);
171 glm::uint32 REG3(z);
172 glm::uint32 REG4(w);
173
174 REG1 = ((REG1 << 12) | REG1) & static_cast<glm::uint32>(0x000F000Fu);
175 REG2 = ((REG2 << 12) | REG2) & static_cast<glm::uint32>(0x000F000Fu);
176 REG3 = ((REG3 << 12) | REG3) & static_cast<glm::uint32>(0x000F000Fu);
177 REG4 = ((REG4 << 12) | REG4) & static_cast<glm::uint32>(0x000F000Fu);
178
179 REG1 = ((REG1 << 6) | REG1) & static_cast<glm::uint32>(0x03030303u);
180 REG2 = ((REG2 << 6) | REG2) & static_cast<glm::uint32>(0x03030303u);
181 REG3 = ((REG3 << 6) | REG3) & static_cast<glm::uint32>(0x03030303u);
182 REG4 = ((REG4 << 6) | REG4) & static_cast<glm::uint32>(0x03030303u);
183
184 REG1 = ((REG1 << 3) | REG1) & static_cast<glm::uint32>(0x11111111u);
185 REG2 = ((REG2 << 3) | REG2) & static_cast<glm::uint32>(0x11111111u);
186 REG3 = ((REG3 << 3) | REG3) & static_cast<glm::uint32>(0x11111111u);
187 REG4 = ((REG4 << 3) | REG4) & static_cast<glm::uint32>(0x11111111u);
188
189 return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
190 }
191
192 template<>
193 GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
194 {
195 glm::uint64 REG1(x);
196 glm::uint64 REG2(y);
197 glm::uint64 REG3(z);
198 glm::uint64 REG4(w);
199
200 REG1 = ((REG1 << 24) | REG1) & static_cast<glm::uint64>(0x000000FF000000FFull);
201 REG2 = ((REG2 << 24) | REG2) & static_cast<glm::uint64>(0x000000FF000000FFull);
202 REG3 = ((REG3 << 24) | REG3) & static_cast<glm::uint64>(0x000000FF000000FFull);
203 REG4 = ((REG4 << 24) | REG4) & static_cast<glm::uint64>(0x000000FF000000FFull);
204
205 REG1 = ((REG1 << 12) | REG1) & static_cast<glm::uint64>(0x000F000F000F000Full);
206 REG2 = ((REG2 << 12) | REG2) & static_cast<glm::uint64>(0x000F000F000F000Full);
207 REG3 = ((REG3 << 12) | REG3) & static_cast<glm::uint64>(0x000F000F000F000Full);
208 REG4 = ((REG4 << 12) | REG4) & static_cast<glm::uint64>(0x000F000F000F000Full);
209
210 REG1 = ((REG1 << 6) | REG1) & static_cast<glm::uint64>(0x0303030303030303ull);
211 REG2 = ((REG2 << 6) | REG2) & static_cast<glm::uint64>(0x0303030303030303ull);
212 REG3 = ((REG3 << 6) | REG3) & static_cast<glm::uint64>(0x0303030303030303ull);
213 REG4 = ((REG4 << 6) | REG4) & static_cast<glm::uint64>(0x0303030303030303ull);
214
215 REG1 = ((REG1 << 3) | REG1) & static_cast<glm::uint64>(0x1111111111111111ull);
216 REG2 = ((REG2 << 3) | REG2) & static_cast<glm::uint64>(0x1111111111111111ull);
217 REG3 = ((REG3 << 3) | REG3) & static_cast<glm::uint64>(0x1111111111111111ull);
218 REG4 = ((REG4 << 3) | REG4) & static_cast<glm::uint64>(0x1111111111111111ull);
219
220 return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
221 }
222}//namespace detail
223
224#if GLM_COMPILER & GLM_COMPILER_CLANG
225# pragma clang diagnostic push
226# pragma clang diagnostic ignored "-Wsign-compare"
227#endif
228
229 template<typename genIUType>
230 GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits)
231 {
232 static_assert(std::numeric_limits<genIUType>::is_integer, "'mask' accepts only integer values");
233
234 return Bits >= static_cast<genIUType>(sizeof(genIUType) * 8) ? ~static_cast<genIUType>(0) : (static_cast<genIUType>(1) << Bits) - static_cast<genIUType>(1);
235 }
236
237#if GLM_COMPILER & GLM_COMPILER_CLANG
238# pragma clang diagnostic pop
239#endif
240
241 template<length_t L, typename T, qualifier Q>
242 GLM_FUNC_QUALIFIER vec<L, T, Q> mask(vec<L, T, Q> const& v)
243 {
244 static_assert(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");
245
246 return detail::functor1<vec, L, T, T, Q>::call(mask, v);
247 }
248
249 template<typename genIType>
250 GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift)
251 {
252 static_assert(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateRight' accepts only integer values");
253
254 int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);
255 return (In << static_cast<genIType>(Shift)) | (In >> static_cast<genIType>(BitSize - Shift));
256 }
257
258 template<length_t L, typename T, qualifier Q>
259 GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldRotateRight(vec<L, T, Q> const& In, int Shift)
260 {
261 static_assert(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");
262
263 int const BitSize = static_cast<int>(sizeof(T) * 8);
264 return (In << static_cast<T>(Shift)) | (In >> static_cast<T>(BitSize - Shift));
265 }
266
267 template<typename genIType>
268 GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift)
269 {
270 static_assert(std::numeric_limits<genIType>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
271
272 int const BitSize = static_cast<genIType>(sizeof(genIType) * 8);
273 return (In >> static_cast<genIType>(Shift)) | (In << static_cast<genIType>(BitSize - Shift));
274 }
275
276 template<length_t L, typename T, qualifier Q>
277 GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldRotateLeft(vec<L, T, Q> const& In, int Shift)
278 {
279 static_assert(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
280
281 int const BitSize = static_cast<int>(sizeof(T) * 8);
282 return (In >> static_cast<T>(Shift)) | (In << static_cast<T>(BitSize - Shift));
283 }
284
285 template<typename genIUType>
286 GLM_FUNC_QUALIFIER genIUType bitfieldFillOne(genIUType Value, int FirstBit, int BitCount)
287 {
288 return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);
289 }
290
291 template<length_t L, typename T, qualifier Q>
292 GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldFillOne(vec<L, T, Q> const& Value, int FirstBit, int BitCount)
293 {
294 return Value | static_cast<T>(mask(BitCount) << FirstBit);
295 }
296
297 template<typename genIUType>
298 GLM_FUNC_QUALIFIER genIUType bitfieldFillZero(genIUType Value, int FirstBit, int BitCount)
299 {
300 return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));
301 }
302
303 template<length_t L, typename T, qualifier Q>
304 GLM_FUNC_QUALIFIER vec<L, T, Q> bitfieldFillZero(vec<L, T, Q> const& Value, int FirstBit, int BitCount)
305 {
306 return Value & static_cast<T>(~(mask(BitCount) << FirstBit));
307 }
308
309 GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)
310 {
311 union sign8
312 {
313 int8 i;
314 uint8 u;
315 } sign_x, sign_y;
316
317 union sign16
318 {
319 int16 i;
320 uint16 u;
321 } result;
322
323 sign_x.i = x;
324 sign_y.i = y;
325 result.u = bitfieldInterleave(sign_x.u, sign_y.u);
326
327 return result.i;
328 }
329
330 GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)
331 {
332 return detail::bitfieldInterleave<uint8, uint16>(x, y);
333 }
334
335 GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(u8vec2 const& v)
336 {
337 return detail::bitfieldInterleave<uint8, uint16>(v.x, v.y);
338 }
339
340 GLM_FUNC_QUALIFIER u8vec2 bitfieldDeinterleave(glm::uint16 x)
341 {
342 uint16 REG1(x);
343 uint16 REG2(x >>= 1);
344
345 REG1 = REG1 & static_cast<uint16>(0x5555);
346 REG2 = REG2 & static_cast<uint16>(0x5555);
347
348 REG1 = ((REG1 >> 1) | REG1) & static_cast<uint16>(0x3333);
349 REG2 = ((REG2 >> 1) | REG2) & static_cast<uint16>(0x3333);
350
351 REG1 = ((REG1 >> 2) | REG1) & static_cast<uint16>(0x0F0F);
352 REG2 = ((REG2 >> 2) | REG2) & static_cast<uint16>(0x0F0F);
353
354 REG1 = ((REG1 >> 4) | REG1) & static_cast<uint16>(0x00FF);
355 REG2 = ((REG2 >> 4) | REG2) & static_cast<uint16>(0x00FF);
356
357 REG1 = ((REG1 >> 8) | REG1) & static_cast<uint16>(0xFFFF);
358 REG2 = ((REG2 >> 8) | REG2) & static_cast<uint16>(0xFFFF);
359
360 return glm::u8vec2(REG1, REG2);
361 }
362
363 GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)
364 {
365 union sign16
366 {
367 int16 i;
368 uint16 u;
369 } sign_x, sign_y;
370
371 union sign32
372 {
373 int32 i;
374 uint32 u;
375 } result;
376
377 sign_x.i = x;
378 sign_y.i = y;
379 result.u = bitfieldInterleave(sign_x.u, sign_y.u);
380
381 return result.i;
382 }
383
384 GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)
385 {
386 return detail::bitfieldInterleave<uint16, uint32>(x, y);
387 }
388
389 GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(u16vec2 const& v)
390 {
391 return detail::bitfieldInterleave<uint16, uint32>(v.x, v.y);
392 }
393
394 GLM_FUNC_QUALIFIER glm::u16vec2 bitfieldDeinterleave(glm::uint32 x)
395 {
396 glm::uint32 REG1(x);
397 glm::uint32 REG2(x >>= 1);
398
399 REG1 = REG1 & static_cast<glm::uint32>(0x55555555);
400 REG2 = REG2 & static_cast<glm::uint32>(0x55555555);
401
402 REG1 = ((REG1 >> 1) | REG1) & static_cast<glm::uint32>(0x33333333);
403 REG2 = ((REG2 >> 1) | REG2) & static_cast<glm::uint32>(0x33333333);
404
405 REG1 = ((REG1 >> 2) | REG1) & static_cast<glm::uint32>(0x0F0F0F0F);
406 REG2 = ((REG2 >> 2) | REG2) & static_cast<glm::uint32>(0x0F0F0F0F);
407
408 REG1 = ((REG1 >> 4) | REG1) & static_cast<glm::uint32>(0x00FF00FF);
409 REG2 = ((REG2 >> 4) | REG2) & static_cast<glm::uint32>(0x00FF00FF);
410
411 REG1 = ((REG1 >> 8) | REG1) & static_cast<glm::uint32>(0x0000FFFF);
412 REG2 = ((REG2 >> 8) | REG2) & static_cast<glm::uint32>(0x0000FFFF);
413
414 return glm::u16vec2(REG1, REG2);
415 }
416
417 GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)
418 {
419 union sign32
420 {
421 int32 i;
422 uint32 u;
423 } sign_x, sign_y;
424
425 union sign64
426 {
427 int64 i;
428 uint64 u;
429 } result;
430
431 sign_x.i = x;
432 sign_y.i = y;
433 result.u = bitfieldInterleave(sign_x.u, sign_y.u);
434
435 return result.i;
436 }
437
438 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)
439 {
440 return detail::bitfieldInterleave<uint32, uint64>(x, y);
441 }
442
443 GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(u32vec2 const& v)
444 {
445 return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y);
446 }
447
448 GLM_FUNC_QUALIFIER glm::u32vec2 bitfieldDeinterleave(glm::uint64 x)
449 {
450 glm::uint64 REG1(x);
451 glm::uint64 REG2(x >>= 1);
452
453 REG1 = REG1 & static_cast<glm::uint64>(0x5555555555555555ull);
454 REG2 = REG2 & static_cast<glm::uint64>(0x5555555555555555ull);
455
456 REG1 = ((REG1 >> 1) | REG1) & static_cast<glm::uint64>(0x3333333333333333ull);
457 REG2 = ((REG2 >> 1) | REG2) & static_cast<glm::uint64>(0x3333333333333333ull);
458
459 REG1 = ((REG1 >> 2) | REG1) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
460 REG2 = ((REG2 >> 2) | REG2) & static_cast<glm::uint64>(0x0F0F0F0F0F0F0F0Full);
461
462 REG1 = ((REG1 >> 4) | REG1) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
463 REG2 = ((REG2 >> 4) | REG2) & static_cast<glm::uint64>(0x00FF00FF00FF00FFull);
464
465 REG1 = ((REG1 >> 8) | REG1) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
466 REG2 = ((REG2 >> 8) | REG2) & static_cast<glm::uint64>(0x0000FFFF0000FFFFull);
467
468 REG1 = ((REG1 >> 16) | REG1) & static_cast<glm::uint64>(0x00000000FFFFFFFFull);
469 REG2 = ((REG2 >> 16) | REG2) & static_cast<glm::uint64>(0x00000000FFFFFFFFull);
470
471 return glm::u32vec2(REG1, REG2);
472 }
473
474 GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)
475 {
476 union sign8
477 {
478 int8 i;
479 uint8 u;
480 } sign_x, sign_y, sign_z;
481
482 union sign32
483 {
484 int32 i;
485 uint32 u;
486 } result;
487
488 sign_x.i = x;
489 sign_y.i = y;
490 sign_z.i = z;
491 result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
492
493 return result.i;
494 }
495
496 GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
497 {
498 return detail::bitfieldInterleave<uint8, uint32>(x, y, z);
499 }
500
501 GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec3 const& v)
502 {
503 return detail::bitfieldInterleave<uint8, uint32>(v.x, v.y, v.z);
504 }
505
506 GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)
507 {
508 union sign16
509 {
510 int16 i;
511 uint16 u;
512 } sign_x, sign_y, sign_z;
513
514 union sign64
515 {
516 int64 i;
517 uint64 u;
518 } result;
519
520 sign_x.i = x;
521 sign_y.i = y;
522 sign_z.i = z;
523 result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
524
525 return result.i;
526 }
527
528 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
529 {
530 return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
531 }
532
533 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec3 const& v)
534 {
535 return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y, v.z);
536 }
537
538 GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)
539 {
540 union sign16
541 {
542 int32 i;
543 uint32 u;
544 } sign_x, sign_y, sign_z;
545
546 union sign64
547 {
548 int64 i;
549 uint64 u;
550 } result;
551
552 sign_x.i = x;
553 sign_y.i = y;
554 sign_z.i = z;
555 result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
556
557 return result.i;
558 }
559
560 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
561 {
562 return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
563 }
564
565 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u32vec3 const& v)
566 {
567 return detail::bitfieldInterleave<uint32, uint64>(v.x, v.y, v.z);
568 }
569
570 GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
571 {
572 union sign8
573 {
574 int8 i;
575 uint8 u;
576 } sign_x, sign_y, sign_z, sign_w;
577
578 union sign32
579 {
580 int32 i;
581 uint32 u;
582 } result;
583
584 sign_x.i = x;
585 sign_y.i = y;
586 sign_z.i = z;
587 sign_w.i = w;
588 result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
589
590 return result.i;
591 }
592
593 GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
594 {
595 return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);
596 }
597
598 GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(u8vec4 const& v)
599 {
600 return detail::bitfieldInterleave<uint8, uint32>(v.x, v.y, v.z, v.w);
601 }
602
603 GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
604 {
605 union sign16
606 {
607 int16 i;
608 uint16 u;
609 } sign_x, sign_y, sign_z, sign_w;
610
611 union sign64
612 {
613 int64 i;
614 uint64 u;
615 } result;
616
617 sign_x.i = x;
618 sign_y.i = y;
619 sign_z.i = z;
620 sign_w.i = w;
621 result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
622
623 return result.i;
624 }
625
626 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
627 {
628 return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);
629 }
630
631 GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(u16vec4 const& v)
632 {
633 return detail::bitfieldInterleave<uint16, uint64>(v.x, v.y, v.z, v.w);
634 }
635}//namespace glm